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;
}
gboolean populate_files (gpointer data) //TODO:: show an spinner while loading
{
FilebrowserBackend *filebackend= FILEBROWSER_BACKEND(data);
FilebrowserBackendDetails *directory = FILEBROWSER_BACKEND_GET_PRIVATE(filebackend);
GDK_THREADS_ENTER();
if (g_cancellable_is_cancelled (directory->cancellable)){
GDK_THREADS_LEAVE();
return FALSE; /* remove source */
}
GError *error=NULL;
GFileInfo *info = g_file_enumerator_next_file (directory->enumerator, directory->cancellable, &error);
if (info){
const gchar *mime= g_file_info_get_content_type (info);
if (!g_file_info_get_is_hidden (info) && !g_file_info_get_is_backup (info)){
if (MIME_ISDIR(mime)){
//if has dot in name pos 0 don't process
const gchar *folder=g_file_info_get_display_name(info);
if(folder[0]!='.'){
FOLDERFILE *current;
current=new_folderfile();
current->mime=g_strdup(mime);
GIcon *icon =g_file_info_get_icon(info);
current->icon= g_icon_to_string (icon);
current->display_name=g_strdup(folder);
/* add to list */
directory->filesinfolder = g_slist_append(directory->filesinfolder, current);
}
} else {
if (IS_TEXT(mime) && !IS_APPLICATION(mime)){
//files
FOLDERFILE *current;
current=new_folderfile();
current->mime=g_strdup(mime);
GIcon *icon =g_file_info_get_icon(info);
current->icon= g_icon_to_string (icon);
current->display_name=g_strdup(g_file_info_get_display_name(info));
/* add to list */
directory->filesinfolder = g_slist_append(directory->filesinfolder, current);
}
}
}
g_object_unref(info);
} else {
if (error){
g_print(_("Error::%s"),error->message);
g_error_free (error);
}
GDK_THREADS_LEAVE();
return FALSE; /* remove source */
}
GDK_THREADS_LEAVE();
return TRUE;
}
static void
show_info (GFileInfo *info)
{
const char *name, *type;
goffset size;
char **attributes;
int i;
gboolean first_attr;
if ((g_file_info_get_is_hidden (info)) && !show_hidden)
return;
name = g_file_info_get_name (info);
if (name == NULL)
name = "";
size = g_file_info_get_size (info);
type = type_to_string (g_file_info_get_file_type (info));
if (show_long)
g_print ("%s\t%"G_GUINT64_FORMAT"\t(%s)", name, (guint64)size, type);
else
g_print ("%s", name);
first_attr = TRUE;
attributes = g_file_info_list_attributes (info, NULL);
for (i = 0 ; attributes[i] != NULL; i++)
{
char *val_as_string;
if (!show_long ||
strcmp (attributes[i], G_FILE_ATTRIBUTE_STANDARD_NAME) == 0 ||
strcmp (attributes[i], G_FILE_ATTRIBUTE_STANDARD_SIZE) == 0 ||
strcmp (attributes[i], G_FILE_ATTRIBUTE_STANDARD_TYPE) == 0 ||
strcmp (attributes[i], G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN) == 0)
continue;
if (first_attr)
{
g_print ("\t");
first_attr = FALSE;
}
else
g_print (" ");
val_as_string = g_file_info_get_attribute_as_string (info, attributes[i]);
g_print ("%s=%s", attributes[i], val_as_string);
g_free (val_as_string);
}
g_strfreev (attributes);
g_print ("\n");
}
/**
* 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;
}
static void
gimp_module_db_load_directory (GimpModuleDB *db,
GFile *directory)
{
GFileEnumerator *enumerator;
enumerator = g_file_enumerate_children (directory,
G_FILE_ATTRIBUTE_STANDARD_NAME ","
G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN ","
G_FILE_ATTRIBUTE_STANDARD_TYPE,
G_FILE_QUERY_INFO_NONE,
NULL, NULL);
if (enumerator)
{
GFileInfo *info;
while ((info = g_file_enumerator_next_file (enumerator, NULL, NULL)))
{
GFileType file_type = g_file_info_get_file_type (info);
if (file_type == G_FILE_TYPE_REGULAR &&
! g_file_info_get_is_hidden (info))
{
GFile *child = g_file_enumerator_get_child (enumerator, info);
gimp_module_db_load_module (db, child);
g_object_unref (child);
}
g_object_unref (info);
}
g_object_unref (enumerator);
}
}
static void
get_folder_content_done_cb (GError *error,
gpointer user_data)
{
LoadData *load_data = user_data;
FrFileSelectorDialog *self = load_data->dialog;
GtkListStore *list_store;
GList *scan;
GtkTreeIter iter;
GDateTime *today;
int sort_column_id;
GtkSortType sort_order;
GHashTable *selected_files;
if (error != NULL) {
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_MOUNTED)) {
GMountOperation *operation;
operation = gtk_mount_operation_new (GTK_WINDOW (self));
g_file_mount_enclosing_volume (load_data->folder,
G_MOUNT_MOUNT_NONE,
operation,
load_data->cancellable,
folder_mount_enclosing_volume_ready_cb,
load_data);
g_object_unref (operation);
return;
}
if (! g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
_gtk_error_dialog_run (GTK_WINDOW (self), _("Could not load the location"), "%s", error->message);
if (load_data->dialog->priv->current_operation == load_data)
load_data->dialog->priv->current_operation = NULL;
load_data_free (load_data);
return;
}
load_data->files = g_list_reverse (load_data->files);
today = g_date_time_new_now_local ();
gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (GET_WIDGET ("files_liststore")), &sort_column_id, &sort_order);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (GET_WIDGET ("files_liststore")), GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID, 0);
selected_files = g_hash_table_new (g_file_hash, (GEqualFunc) g_file_equal);
for (scan = load_data->files_to_select; scan; scan = scan->next)
g_hash_table_insert(selected_files, scan->data, GINT_TO_POINTER (1));
list_store = GTK_LIST_STORE (GET_WIDGET ("files_liststore"));
gtk_list_store_clear (list_store);
for (scan = load_data->files; scan; scan = scan->next) {
FileInfo *file_info = scan->data;
GdkPixbuf *icon_pixbuf;
char *size;
GTimeVal timeval;
GDateTime *datetime;
char *modified;
char *collate_key;
gboolean is_folder;
if (! self->priv->show_hidden && g_file_info_get_is_hidden (file_info->info))
continue;
gtk_list_store_append (list_store, &iter);
icon_pixbuf = gth_icon_cache_get_pixbuf (self->priv->icon_cache, g_file_info_get_icon (file_info->info));
size = g_format_size (g_file_info_get_size (file_info->info));
g_file_info_get_modification_time (file_info->info, &timeval);
datetime = g_date_time_new_from_timeval_local (&timeval);
modified = g_date_time_format (datetime, _g_date_time_same_day (datetime, today) ? "%X" : "%x");
collate_key = g_utf8_collate_key_for_filename (g_file_info_get_display_name (file_info->info), -1);
is_folder = (g_file_info_get_file_type (file_info->info) == G_FILE_TYPE_DIRECTORY);
gtk_list_store_set (list_store, &iter,
FILE_LIST_COLUMN_ICON, icon_pixbuf,
FILE_LIST_COLUMN_NAME, g_file_info_get_display_name (file_info->info),
FILE_LIST_COLUMN_SIZE, (is_folder ? "" : size),
FILE_LIST_COLUMN_MODIFIED, modified,
FILE_LIST_COLUMN_FILE, file_info->file,
FILE_LIST_COLUMN_NAME_ORDER, collate_key,
FILE_LIST_COLUMN_SIZE_ORDER, g_file_info_get_size (file_info->info),
FILE_LIST_COLUMN_MODIFIED_ORDER, timeval.tv_sec,
FILE_LIST_COLUMN_IS_FOLDER, is_folder,
FILE_LIST_COLUMN_IS_SELECTED, (g_hash_table_lookup (selected_files, file_info->file) != NULL),
-1);
g_free (collate_key);
g_free (modified);
g_date_time_unref (datetime);
g_free (size);
_g_object_unref (icon_pixbuf);
}
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (GET_WIDGET ("files_liststore")), sort_column_id, sort_order);
set_current_folder (self, load_data->folder);
if (load_data->dialog->priv->current_operation == load_data)
load_data->dialog->priv->current_operation = NULL;
g_hash_table_unref (selected_files);
g_date_time_unref (today);
load_data_free (load_data);
}
/**
* as_utils_find_files_matching:
*/
GPtrArray*
as_utils_find_files_matching (const gchar* dir, const gchar* pattern, gboolean recursive, GError **error)
{
GPtrArray *list;
GFileInfo *file_info;
GFileEnumerator *enumerator = NULL;
GFile *fdir;
GError *tmp_error = NULL;
g_return_val_if_fail (dir != NULL, NULL);
g_return_val_if_fail (pattern != NULL, NULL);
list = g_ptr_array_new_with_free_func (g_free);
fdir = g_file_new_for_path (dir);
enumerator = g_file_enumerate_children (fdir, G_FILE_ATTRIBUTE_STANDARD_NAME, 0, NULL, &tmp_error);
if (tmp_error != NULL)
goto out;
while ((file_info = g_file_enumerator_next_file (enumerator, NULL, &tmp_error)) != NULL) {
g_autofree gchar *path = NULL;
if (tmp_error != NULL) {
g_object_unref (file_info);
break;
}
if (g_file_info_get_is_hidden (file_info)) {
g_object_unref (file_info);
continue;
}
path = g_build_filename (dir,
g_file_info_get_name (file_info),
NULL);
if ((!g_file_test (path, G_FILE_TEST_IS_REGULAR)) && (recursive)) {
GPtrArray *subdir_list;
guint i;
subdir_list = as_utils_find_files_matching (path, pattern, recursive, &tmp_error);
/* if there was an error, exit */
if (subdir_list == NULL) {
g_ptr_array_unref (list);
list = NULL;
g_object_unref (file_info);
break;
}
for (i=0; i<subdir_list->len; i++)
g_ptr_array_add (list,
g_strdup ((gchar *) g_ptr_array_index (subdir_list, i)));
g_ptr_array_unref (subdir_list);
} else {
if (!as_str_empty (pattern)) {
if (!g_pattern_match_simple (pattern, g_file_info_get_name (file_info))) {
g_object_unref (file_info);
continue;
}
}
g_ptr_array_add (list, path);
path = NULL;
}
g_object_unref (file_info);
}
out:
g_object_unref (fdir);
if (enumerator != NULL)
g_object_unref (enumerator);
if (tmp_error != NULL) {
if (error == NULL)
g_debug ("Error while searching for files in %s: %s", dir, tmp_error->message);
else
g_propagate_error (error, tmp_error);
g_ptr_array_unref (list);
return NULL;
}
return list;
}
static void
do_tree (GFile *f, int level, guint64 pattern)
{
GFileEnumerator *enumerator;
GError *error = NULL;
unsigned int n;
GFileInfo *info;
info = g_file_query_info (f,
G_FILE_ATTRIBUTE_STANDARD_TYPE ","
G_FILE_ATTRIBUTE_STANDARD_TARGET_URI,
0,
NULL, NULL);
if (info != NULL)
{
if (g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_STANDARD_TYPE) == G_FILE_TYPE_MOUNTABLE)
{
/* don't process mountables; we avoid these by getting the target_uri below */
g_object_unref (info);
return;
}
g_object_unref (info);
}
enumerator = g_file_enumerate_children (f,
G_FILE_ATTRIBUTE_STANDARD_NAME ","
G_FILE_ATTRIBUTE_STANDARD_TYPE ","
G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN ","
G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK ","
G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET ","
G_FILE_ATTRIBUTE_STANDARD_TARGET_URI,
0,
NULL,
&error);
if (enumerator != NULL)
{
GList *l;
GList *info_list;
info_list = NULL;
while ((info = g_file_enumerator_next_file (enumerator, NULL, NULL)) != NULL)
{
if (g_file_info_get_is_hidden (info) && !show_hidden)
{
g_object_unref (info);
}
else
{
info_list = g_list_prepend (info_list, info);
}
}
g_file_enumerator_close (enumerator, NULL, NULL);
info_list = g_list_sort (info_list, (GCompareFunc) sort_info_by_name);
for (l = info_list; l != NULL; l = l->next)
{
const char *name;
const char *target_uri;
GFileType type;
gboolean is_last_item;
info = l->data;
is_last_item = (l->next == NULL);
name = g_file_info_get_name (info);
type = g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_STANDARD_TYPE);
if (name != NULL)
{
for (n = 0; n < level; n++)
{
if (pattern & (1<<n))
{
g_print ("| ");
}
else
{
g_print (" ");
}
}
if (is_last_item)
{
g_print ("`-- %s", name);
}
else
{
g_print ("|-- %s", name);
}
target_uri = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_STANDARD_TARGET_URI);
if (target_uri != NULL)
{
g_print (" -> %s", target_uri);
}
else
{
if (g_file_info_get_is_symlink (info))
{
const char *target;
target = g_file_info_get_symlink_target (info);
g_print (" -> %s", target);
}
}
g_print ("\n");
if ((type & G_FILE_TYPE_DIRECTORY) &&
(follow_symlinks || !g_file_info_get_is_symlink (info)))
{
guint64 new_pattern;
GFile *child;
if (is_last_item)
new_pattern = pattern;
else
new_pattern = pattern | (1<<level);
child = NULL;
if (target_uri != NULL)
{
if (follow_symlinks)
child = g_file_new_for_uri (target_uri);
}
else
{
child = g_file_get_child (f, name);
}
if (child != NULL)
{
do_tree (child, level + 1, new_pattern);
g_object_unref (child);
}
}
}
g_object_unref (info);
}
g_list_free (info_list);
}
else
{
for (n = 0; n < level; n++)
{
if (pattern & (1<<n))
{
g_print ("| ");
}
else
{
g_print (" ");
}
}
g_print (" [%s]\n", error->message);
g_error_free (error);
}
}
/*
* Recurse the path to create a list of files. Return a GList of the files found.
*/
static GList *
read_directory_recursively (GList *file_list, GFileEnumerator *dir_enumerator,
gboolean recurse)
{
GError *error = NULL;
GFileInfo *info;
const char *file_name;
gboolean is_hidden;
GFileType type;
g_return_val_if_fail (dir_enumerator != NULL, file_list);
while ((info = g_file_enumerator_next_file (dir_enumerator, NULL, &error))
!= NULL)
{
if (Main_Stop_Button_Pressed)
{
g_object_unref (info);
return file_list;
}
file_name = g_file_info_get_name (info);
is_hidden = g_file_info_get_is_hidden (info);
type = g_file_info_get_file_type (info);
/* Hidden directory like '.mydir' will also be browsed if allowed. */
if (!is_hidden || (g_settings_get_boolean (MainSettings,
"browse-show-hidden")
&& is_hidden))
{
if (type == G_FILE_TYPE_DIRECTORY)
{
if (recurse)
{
/* Searching for files recursively. */
GFile *child_dir = g_file_enumerator_get_child (dir_enumerator,
info);
GFileEnumerator *childdir_enumerator;
GError *child_error = NULL;
childdir_enumerator = g_file_enumerate_children (child_dir,
G_FILE_ATTRIBUTE_STANDARD_NAME ","
G_FILE_ATTRIBUTE_STANDARD_TYPE ","
G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN,
G_FILE_QUERY_INFO_NONE,
NULL, &child_error);
if (!childdir_enumerator)
{
gchar *child_path;
gchar *display_path;
child_path = g_file_get_path (child_dir);
display_path = g_filename_display_name (child_path);
Log_Print (LOG_ERROR,
_("Error opening directory ‘%s’: %s"),
display_path, child_error->message);
g_free (display_path);
g_free (child_path);
g_error_free (child_error);
g_object_unref (child_dir);
g_object_unref (info);
continue;
}
file_list = read_directory_recursively (file_list,
childdir_enumerator,
recurse);
g_object_unref (child_dir);
g_file_enumerator_close (childdir_enumerator, NULL,
&error);
g_object_unref (childdir_enumerator);
}
}
else if (type == G_FILE_TYPE_REGULAR &&
et_file_is_supported (file_name))
{
GFile *file = g_file_enumerator_get_child (dir_enumerator, info);
file_list = g_list_append (file_list, file);
}
// Just to not block X events
while (gtk_events_pending())
gtk_main_iteration();
}
g_object_unref (info);
}
if (error)
{
Log_Print (LOG_ERROR, _("Cannot read directory ‘%s’"), error->message);
g_error_free (error);
}
return file_list;
}
static void
visit_directory (GFile *dir, SearchThreadData *data)
{
GFileEnumerator *enumerator;
GFileInfo *info;
GFile *child;
const char *mime_type, *display_name;
char *lower_name, *normalized;
gboolean hit;
int i;
GList *l;
const char *id;
gboolean visited;
enumerator = g_file_enumerate_children (dir,
data->mime_types != NULL ?
STD_ATTRIBUTES ","
G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE
:
STD_ATTRIBUTES
,
0, data->cancellable, NULL);
if (enumerator == NULL) {
return;
}
while ((info = g_file_enumerator_next_file (enumerator, data->cancellable, NULL)) != NULL) {
if (g_file_info_get_is_hidden (info)) {
goto next;
}
display_name = g_file_info_get_display_name (info);
if (display_name == NULL) {
goto next;
}
normalized = g_utf8_normalize (display_name, -1, G_NORMALIZE_NFD);
lower_name = g_utf8_strdown (normalized, -1);
g_free (normalized);
hit = data->words_and;
for (i = 0; data->words[i] != NULL; i++) {
if (data->word_strstr[i]) {
if ((strstr (lower_name, data->words[i]) != NULL)^data->words_and) {
hit = !data->words_and;
break;
}
}
else if (strwildcardcmp (data->words[i], lower_name)^data->words_and) {
hit = !data->words_and;
break;
}
}
g_free (lower_name);
if (hit && data->mime_types) {
mime_type = g_file_info_get_content_type (info);
hit = FALSE;
for (l = data->mime_types; mime_type != NULL && l != NULL; l = l->next) {
if (g_content_type_equals (mime_type, l->data)) {
hit = TRUE;
break;
}
}
}
child = g_file_get_child (dir, g_file_info_get_name (info));
if (hit) {
data->uri_hits = g_list_prepend (data->uri_hits, g_file_get_uri (child));
}
data->n_processed_files++;
if (data->n_processed_files > BATCH_SIZE) {
send_batch (data);
}
if (g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY) {
id = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_ID_FILE);
visited = FALSE;
if (id) {
if (g_hash_table_lookup_extended (data->visited,
id, NULL, NULL)) {
visited = TRUE;
} else {
g_hash_table_insert (data->visited, g_strdup (id), NULL);
}
}
if (!visited) {
g_queue_push_tail (data->directories, g_object_ref (child));
}
}
g_object_unref (child);
next:
g_object_unref (info);
}
g_object_unref (enumerator);
}
void
icon_themes_init (Gimp *gimp)
{
GimpGuiConfig *config;
g_return_if_fail (GIMP_IS_GIMP (gimp));
config = GIMP_GUI_CONFIG (gimp->config);
icon_themes_hash = g_hash_table_new_full (g_str_hash,
g_str_equal,
g_free,
g_object_unref);
if (config->icon_theme_path)
{
GList *path;
GList *list;
path = gimp_config_path_expand_to_files (config->icon_theme_path, NULL);
for (list = path; list; list = g_list_next (list))
{
GFile *dir = list->data;
GFileEnumerator *enumerator;
enumerator =
g_file_enumerate_children (dir,
G_FILE_ATTRIBUTE_STANDARD_NAME ","
G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN ","
G_FILE_ATTRIBUTE_STANDARD_TYPE,
G_FILE_QUERY_INFO_NONE,
NULL, NULL);
if (enumerator)
{
GFileInfo *info;
while ((info = g_file_enumerator_next_file (enumerator,
NULL, NULL)))
{
if (! g_file_info_get_is_hidden (info) &&
g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY)
{
GFile *file;
GFile *index_theme;
file = g_file_enumerator_get_child (enumerator, info);
/* make sure there is a hicolor/index.theme file */
index_theme = g_file_get_child (file, "index.theme");
if (g_file_query_exists (index_theme, NULL))
{
const gchar *name;
gchar *basename;
name = gimp_file_get_utf8_name (file);
basename = g_path_get_basename (name);
if (strcmp ("hicolor", basename))
{
if (gimp->be_verbose)
g_print ("Adding icon theme '%s' (%s)\n",
basename, name);
g_hash_table_insert (icon_themes_hash, basename,
g_object_ref (file));
}
else
{
g_free (basename);
}
}
g_object_unref (index_theme);
g_object_unref (file);
}
g_object_unref (info);
}
g_object_unref (enumerator);
}
}
g_list_free_full (path, (GDestroyNotify) g_object_unref);
}
g_signal_connect (config, "notify::icon-theme",
G_CALLBACK (icons_theme_change_notify),
gimp);
icons_theme_change_notify (config, NULL, gimp);
}
GList *vfs_backend_list_directory (const gchar *cBaseURI, CairoDockFMSortType iSortType, int iNewIconsType, gboolean bListHiddenFiles, gchar **cFullURI)
{
g_return_val_if_fail (cBaseURI != NULL, NULL);
cd_message ("%s (%s)", __func__, cBaseURI);
gchar *cURI;
gboolean bAddHome = FALSE;
if (strcmp (cBaseURI, CAIRO_DOCK_FM_VFS_ROOT) == 0)
{
cURI = g_strdup ("computer://");
bAddHome = TRUE;
///*cFullURI = cURI;
///return vfs_backend_list_volumes ();
//vfs_backend_list_volumes ();
}
else if (strcmp (cBaseURI, CAIRO_DOCK_FM_NETWORK) == 0)
cURI = g_strdup ("network://");
else
cURI = (*cBaseURI == '/' ? g_strconcat ("file://", cBaseURI, NULL) : g_strdup (cBaseURI));
*cFullURI = cURI;
GFile *pFile = g_file_new_for_uri (cURI);
GError *erreur = NULL;
const gchar *cAttributes = G_FILE_ATTRIBUTE_STANDARD_TYPE","
G_FILE_ATTRIBUTE_STANDARD_SIZE","
G_FILE_ATTRIBUTE_TIME_MODIFIED","
G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE","
G_FILE_ATTRIBUTE_STANDARD_NAME","
G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN","
G_FILE_ATTRIBUTE_STANDARD_ICON","
G_FILE_ATTRIBUTE_STANDARD_TARGET_URI","
G_FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE;
GFileEnumerator *pFileEnum = g_file_enumerate_children (pFile,
cAttributes,
G_FILE_QUERY_INFO_NONE, /// G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS
NULL,
&erreur);
//g_object_unref (pFile);
if (erreur != NULL)
{
cd_warning ("gnome_integration : %s", erreur->message);
g_error_free (erreur);
return NULL;
}
int iOrder = 0;
GList *pIconList = NULL;
Icon *icon;
GFileInfo *pFileInfo;
do
{
pFileInfo = g_file_enumerator_next_file (pFileEnum, NULL, &erreur);
if (erreur != NULL)
{
cd_warning ("gnome_integration : %s", erreur->message);
g_error_free (erreur);
erreur = NULL;
continue;
}
if (pFileInfo == NULL)
break ;
gboolean bIsHidden = g_file_info_get_is_hidden (pFileInfo);
if (bListHiddenFiles || ! bIsHidden)
{
GFileType iFileType = g_file_info_get_file_type (pFileInfo);
GIcon *pFileIcon = g_file_info_get_icon (pFileInfo);
if (pFileIcon == NULL)
{
cd_message ("AUCUNE ICONE");
continue;
}
const gchar *cFileName = g_file_info_get_name (pFileInfo);
const gchar *cMimeType = g_file_info_get_content_type (pFileInfo);
gchar *cName = NULL;
icon = g_new0 (Icon, 1);
icon->iType = iNewIconsType;
icon->cBaseURI = g_strconcat (*cFullURI, "/", cFileName, NULL);
cd_message ("+ %s (mime:%s)", icon->cBaseURI, cMimeType);
if (iFileType == G_FILE_TYPE_MOUNTABLE)
{
const gchar *cTargetURI = g_file_info_get_attribute_string (pFileInfo, G_FILE_ATTRIBUTE_STANDARD_TARGET_URI);
cd_message (" c'est un point de montage correspondant a %s", cTargetURI);
GMount *pMount = NULL;
if (cTargetURI != NULL)
{
icon->acCommand = g_strdup (cTargetURI);
GFile *file = g_file_new_for_uri (cTargetURI);
pMount = g_file_find_enclosing_mount (file, NULL, NULL);
//g_object_unref (file);
}
if (pMount != NULL)
{
cName = g_mount_get_name (pMount);
cd_message ("un GMount existe (%s)", cName);
GVolume *volume = g_mount_get_volume (pMount);
if (volume)
cd_message (" volume associe : %s", g_volume_get_name (volume));
GDrive *drive = g_mount_get_drive (pMount);
if (drive)
cd_message (" disque associe : %s", g_drive_get_name (drive));
///pFileIcon = g_mount_get_icon (pMount);
}
else
{
cName = g_strdup (cFileName);
gchar *str = strrchr (cName, '.'); // on vire l'extension ".volume" ou ".drive".
if (str != NULL)
{
*str = '\0';
if (strcmp (str+1, "link") == 0)
{
if (strcmp (cName, "root") == 0)
{
g_free (cName);
cName = g_strdup ("/");
}
}
else if (strcmp (str+1, "drive") == 0) // on cherche un nom plus parlant si possible.
{
gchar *cVolumeName = _cd_find_volume_name_from_drive_name (cName);
if (cVolumeName != NULL)
{
g_free (cName);
g_free (cVolumeName);
continue; /// apparemment il n'est plus necessaire d'afficher les .drives qui ont 1 (ou plusieurs ?) volumes, car ces derniers sont dans la liste, donc ca fait redondant.
/**if (strcmp (cVolumeName, "discard") == 0)
continue;
g_free (cName);
cName = cVolumeName;*/
}
}
}
}
icon->iVolumeID = 1;
cd_message ("le nom de ce volume est : %s", cName);
}
else
cName = g_strdup (cFileName);
if (icon->acCommand == NULL)
icon->acCommand = g_strdup (icon->cBaseURI);
icon->acName = cName;
icon->acFileName = NULL;
if (cMimeType != NULL && strncmp (cMimeType, "image", 5) == 0)
{
gchar *cHostname = NULL;
gchar *cFilePath = g_filename_from_uri (icon->cBaseURI, &cHostname, &erreur);
if (erreur != NULL)
{
g_error_free (erreur);
erreur = NULL;
}
else if (cHostname == NULL || strcmp (cHostname, "localhost") == 0) // on ne recupere la vignette que sur les fichiers locaux.
{
icon->acFileName = g_strdup (cFilePath);
cairo_dock_remove_html_spaces (icon->acFileName);
}
g_free (cHostname);
g_free (cFilePath);
}
if (icon->acFileName == NULL)
{
icon->acFileName = _cd_get_icon_path (pFileIcon);
cd_message ("icon->acFileName : %s", icon->acFileName);
}
if (iSortType == CAIRO_DOCK_FM_SORT_BY_SIZE)
icon->fOrder = g_file_info_get_size (pFileInfo);
else if (iSortType == CAIRO_DOCK_FM_SORT_BY_DATE)
{
GTimeVal t;
g_file_info_get_modification_time (pFileInfo, &t);
icon->fOrder = t.tv_sec;
}
else if (iSortType == CAIRO_DOCK_FM_SORT_BY_TYPE)
icon->fOrder = (cMimeType != NULL ? *((int *) cMimeType) : 0);
if (icon->fOrder == 0) // un peu moyen mais mieux que rien non ?
icon->fOrder = iOrder;
pIconList = g_list_insert_sorted (pIconList,
icon,
(GCompareFunc) cairo_dock_compare_icons_order);
//g_list_prepend (pIconList, icon);
iOrder ++;
}
} while (TRUE); // 'g_file_enumerator_close' est appelee lors du dernier 'g_file_enumerator_next_file'.
if (bAddHome && pIconList != NULL)
{
icon = g_new0 (Icon, 1);
icon->iType = iNewIconsType;
icon->cBaseURI = g_strdup_printf ("file://%s", "/home");
icon->acCommand = g_strdup ("/home");
//icon->acCommand = g_strdup (icon->cBaseURI);
icon->iVolumeID = 0;
icon->acName = g_strdup ("home");
Icon *pRootIcon = cairo_dock_get_icon_with_name (pIconList, "/");
if (pRootIcon == NULL)
{
pRootIcon = cairo_dock_get_first_icon (pIconList);
g_print ("domage ! (%s:%s)\n", pRootIcon->acCommand, pRootIcon->acName);
}
icon->acFileName = g_strdup (pRootIcon->acFileName);
icon->fOrder = iOrder++;
pIconList = g_list_insert_sorted (pIconList,
icon,
(GCompareFunc) cairo_dock_compare_icons_order);
}
if (iSortType == CAIRO_DOCK_FM_SORT_BY_NAME)
pIconList = cairo_dock_sort_icons_by_name (pIconList);
else
pIconList = cairo_dock_sort_icons_by_order (pIconList);
return pIconList;
}
static gboolean subdir_check_job (GIOSchedulerJob *job, GCancellable *cancellable, gpointer user_data)
{
FmDirTreeModel *dir_tree_model = FM_DIR_TREE_MODEL (user_data);
// Lock ----------------------------------------------------------------------------------------
g_mutex_lock (dir_tree_model->subdir_checks_mutex);
GList *item_list = (GList*) g_queue_pop_head (&dir_tree_model->subdir_checks);
FmDirTreeItem *dir_tree_item = (FmDirTreeItem*) item_list->data;
dir_tree_model->current_subdir_check = item_list;
// If the directory is a Drive, get it's target directory...
//gboolean is_drive = fm_file_info_is_drive (dir_tree_item->file_info);
GFile *gfile;
gboolean is_mountable = fm_file_info_is_mountable (dir_tree_item->file_info);
if (is_mountable)
{
gfile = g_file_new_for_path (fm_file_info_get_target (dir_tree_item->file_info));
}
else
{
gfile = fm_path_to_gfile (fm_file_info_get_path (dir_tree_item->file_info));
}
g_mutex_unlock (dir_tree_model->subdir_checks_mutex);
// Unlock --------------------------------------------------------------------------------------
//~ GError *gerror = NULL;
//~ gfile_info = g_file_query_info (gfile, gfile_info_query_attribs, 0, fm_job_get_cancellable (fmjob), &gerror);
/**
* Parse input directory...
*
*/
char *directory = fm_file_info_get_name (dir_tree_item->file_info);
JOB_DEBUG ("\n----------------------------------------------------------------------------------------------\n");
JOB_DEBUG ("JOB_DEBUG: subdir_check_job: check \"%s\"\n", directory);
JOB_DEBUG ("----------------------------------------------------------------------------------------------\n");
if (is_mountable)
{
JOB_DEBUG ("JOB_DEBUG: subdir_check_job: %s is mountable type !!!\n\n", directory);
}
GFileEnumerator *enumerator = g_file_enumerate_children (gfile,
G_FILE_ATTRIBUTE_STANDARD_NAME","
G_FILE_ATTRIBUTE_STANDARD_TYPE","
G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN,
0, cancellable, NULL);
gboolean has_subdir = FALSE;
if (enumerator)
{
while (!g_cancellable_is_cancelled (cancellable))
{
GFileInfo *gfile_info = g_file_enumerator_next_file (enumerator, cancellable, NULL);
if (G_LIKELY (gfile_info))
{
GFileType g_file_type = g_file_info_get_file_type (gfile_info);
gboolean is_hidden = g_file_info_get_is_hidden (gfile_info);
//~ TREEVIEW_DEBUG ("TREEVIEW_DEBUG: subdir_check_job: GFileInfo for %s = %d\n",
//~ g_file_info_get_name (gfile_info), g_file_type);
g_object_unref (gfile_info);
if (g_file_type == G_FILE_TYPE_DIRECTORY || g_file_type == G_FILE_TYPE_MOUNTABLE)
{
if (dir_tree_model->show_hidden || !is_hidden)
{
JOB_DEBUG ("JOB_DEBUG: subdir_check_job: A directory found in \"%s\" !!!\n\n", directory);
has_subdir = TRUE;
break;
}
}
}
else
{
break;
}
}
GError *error = NULL;
g_file_enumerator_close (enumerator, cancellable, &error);
g_object_unref (enumerator);
}
else
{
JOB_DEBUG ("JOB_DEBUG: subdir_check_job: Error: can't read \"%s\"...\n", directory);
}
// NO_DEBUG ("check result - %s has_dir: %d\n", g_file_get_parse_name (gfile), has_subdir);
g_object_unref (gfile);
if (!has_subdir)
{
JOB_DEBUG ("JOB_DEBUG: subdir_check_job: No directory found in \"%s\"\n\t\t\t > Remove place holder\n\n",
directory);
return g_io_scheduler_job_send_to_mainloop (job,
(GSourceFunc) subdir_check_remove_place_holder,
dir_tree_model, NULL);
}
return subdir_check_finish (dir_tree_model);
}
