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); }