static void on_file_info_job_finished(FmFileInfoJob* job, gpointer user_data) { FmPlacesModel* model = FM_PLACES_MODEL(user_data); GList* l; GtkTreeIter it; FmPlaceItem* item; FmFileInfo* fi; /* g_debug("file info job finished"); */ model->jobs = g_slist_remove(model->jobs, job); if(!gtk_tree_model_get_iter_first(GTK_TREE_MODEL(model), &it)) return; if(fm_list_is_empty(job->file_infos)) return; /* optimize for one file case */ if(fm_list_get_length(job->file_infos) == 1) { fi = FM_FILE_INFO(fm_list_peek_head(job->file_infos)); do { item = NULL; gtk_tree_model_get(GTK_TREE_MODEL(model), &it, FM_PLACES_MODEL_COL_INFO, &item, -1); if( item && item->fi && item->fi->path && fm_path_equal(item->fi->path, fi->path) ) { fm_file_info_unref(item->fi); item->fi = fm_file_info_ref(fi); break; } }while(gtk_tree_model_iter_next(GTK_TREE_MODEL(model), &it)); } else { do { item = NULL; gtk_tree_model_get(GTK_TREE_MODEL(model), &it, FM_PLACES_MODEL_COL_INFO, &item, -1); if( item && item->fi && item->fi->path ) { for(l = fm_list_peek_head_link(job->file_infos); l; l = l->next ) { fi = FM_FILE_INFO(l->data); if(fm_path_equal(item->fi->path, fi->path)) { fm_file_info_unref(item->fi); item->fi = fm_file_info_ref(fi); /* remove the file from list to speed up further loading. * This won't cause problem since nobody else if using the list. */ fm_list_delete_link(job->file_infos, l); break; } } } }while(gtk_tree_model_iter_next(GTK_TREE_MODEL(model), &it)); } }
static void fm_dnd_dest_finalize(GObject *object) { FmDndDest *dd; g_return_if_fail(object != NULL); g_return_if_fail(FM_IS_DND_DEST(object)); dd = FM_DND_DEST(object); fm_dnd_dest_set_widget(dd, NULL); if(dd->idle) g_source_remove(dd->idle); if(dd->dest_file) fm_file_info_unref(dd->dest_file); if(dd->src_files) fm_list_unref(dd->src_files); if(dd->mainloop) g_main_loop_unref(dd->mainloop); G_OBJECT_CLASS(fm_dnd_dest_parent_class)->finalize(object); }
void fm_dnd_dest_set_dest_file(FmDndDest* dd, FmFileInfo* dest_file) { if(dd->dest_file == dest_file) return; if(dd->dest_file) fm_file_info_unref(dd->dest_file); dd->dest_file = dest_file ? fm_file_info_ref(dest_file) : NULL; }
static inline void fm_folder_item_free(FmFolderItem* item) { if (item->hinted_disp_name) g_free(item->hinted_disp_name); if( item->icon ) g_object_unref(item->icon); fm_file_info_unref(item->inf); g_slice_free(FmFolderItem, item); }
static void place_item_free(FmPlaceItem* item) { switch(item->type) { case FM_PLACES_ITEM_VOL: g_object_unref(item->vol); break; } fm_file_info_unref(item->fi); g_slice_free(FmPlaceItem, item); }
static inline FmFileInfo *_new_info_for_native_file(FmDirListJob* job, FmPath* path, const char* path_str, GError** err) { FmFileInfo *fi; if (fm_job_is_cancelled(FM_JOB(job))) return NULL; if (!(job->flags & FM_DIR_LIST_JOB_DETAILED)) return fm_file_info_new_from_native_file(path, path_str, err); fi = fm_file_info_new(); fm_file_info_set_path(fi, path); if (fm_file_info_set_from_native_file(fi, path_str, err)) return fi; fm_file_info_unref(fi); return NULL; }
inline static void thumbnail_task_free(ThumbnailTask* task) { if(task->requests) { g_list_foreach(task->requests, (GFunc)fm_thumbnail_request_free, NULL); g_list_free(task->requests); } fm_file_info_unref(task->fi); /* if those strings are dynamically allocated, free them. */ if(task->flags & ALLOC_STRINGS) { g_free(task->uri); g_free(task->normal_path); g_free(task->large_path); } g_slice_free(ThumbnailTask, task); }
gboolean clear_src_cache(FmDndDest* dd) { /* free cached source files */ if(dd->src_files) { fm_list_unref(dd->src_files); dd->src_files = NULL; } if(dd->dest_file) { fm_file_info_unref(dd->dest_file); dd->dest_file = NULL; } dd->src_dev = 0; dd->src_fs_id = NULL; dd->info_type = 0; dd->idle = 0; dd->waiting_data = FALSE; return FALSE; }
static void fm_dir_list_job_dispose(GObject *object) { FmDirListJob *job; g_return_if_fail(object != NULL); g_return_if_fail(FM_IS_DIR_LIST_JOB(object)); job = (FmDirListJob*)object; if(job->dir_path) { fm_path_unref(job->dir_path); job->dir_path = NULL; } if(job->dir_fi) { fm_file_info_unref(job->dir_fi); job->dir_fi = NULL; } if(job->files) { fm_file_info_list_unref(job->files); job->files = NULL; } if(job->delay_add_files_handler) { g_source_remove(job->delay_add_files_handler); job->delay_add_files_handler = 0; g_slist_free_full(job->files_to_add, (GDestroyNotify)fm_file_info_unref); job->files_to_add = NULL; } if (G_OBJECT_CLASS(fm_dir_list_job_parent_class)->dispose) (* G_OBJECT_CLASS(fm_dir_list_job_parent_class)->dispose)(object); }
/** * fm_dir_list_job_set_dir_info * @job: the job that collected listing * @info: a FmFileInfo of the directory being loaded. * * This API is called by the implementation of FmDirListJob only. * Application developers should not use this API most of the time. * * Since: 1.0.2 */ void fm_dir_list_job_set_dir_info(FmDirListJob* job, FmFileInfo* info) { if(job->dir_fi) fm_file_info_unref(job->dir_fi); job->dir_fi = fm_file_info_ref(info); }
static gboolean fm_dir_list_job_run_gio(FmDirListJob* job) { GFileEnumerator *enu; GFileInfo *inf; FmFileInfo* fi; GError *err = NULL; FmJob* fmjob = FM_JOB(job); GFile* gf; const char* query; gf = fm_path_to_gfile(job->dir_path); _retry: inf = g_file_query_info(gf, gfile_info_query_attribs, 0, fm_job_get_cancellable(fmjob), &err); if(!inf ) { FmJobErrorAction act = fm_job_emit_error(fmjob, err, FM_JOB_ERROR_MODERATE); g_error_free(err); if( act == FM_JOB_RETRY ) { err = NULL; goto _retry; } else { g_object_unref(gf); return FALSE; } } if( g_file_info_get_file_type(inf) != G_FILE_TYPE_DIRECTORY) { char *path_str = fm_path_to_str(job->dir_path); err = g_error_new(G_IO_ERROR, G_IO_ERROR_NOT_DIRECTORY, _("The specified directory '%s' is not valid"), path_str); fm_job_emit_error(fmjob, err, FM_JOB_ERROR_CRITICAL); g_free(path_str); g_error_free(err); g_object_unref(gf); g_object_unref(inf); return FALSE; } /* check if FS is R/O and set attr. into inf */ _fm_file_info_job_update_fs_readonly(gf, inf, NULL, NULL); job->dir_fi = fm_file_info_new_from_g_file_data(gf, inf, job->dir_path); g_object_unref(inf); if(G_UNLIKELY(job->flags & FM_DIR_LIST_JOB_DIR_ONLY)) { query = G_FILE_ATTRIBUTE_STANDARD_TYPE","G_FILE_ATTRIBUTE_STANDARD_NAME"," G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN","G_FILE_ATTRIBUTE_STANDARD_IS_BACKUP"," G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK","G_FILE_ATTRIBUTE_STANDARD_IS_VIRTUAL"," G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME"," G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME","G_FILE_ATTRIBUTE_STANDARD_ICON"," G_FILE_ATTRIBUTE_STANDARD_SIZE","G_FILE_ATTRIBUTE_STANDARD_TARGET_URI"," "unix::*,time::*,access::*,id::filesystem"; } else query = gfile_info_query_attribs; enu = g_file_enumerate_children (gf, query, 0, fm_job_get_cancellable(fmjob), &err); g_object_unref(gf); if(enu) { while( ! fm_job_is_cancelled(fmjob) ) { inf = g_file_enumerator_next_file(enu, fm_job_get_cancellable(fmjob), &err); if(inf) { FmPath *dir, *sub; GFile *child; if(G_UNLIKELY(job->flags & FM_DIR_LIST_JOB_DIR_ONLY)) { /* FIXME: handle symlinks */ if(g_file_info_get_file_type(inf) != G_FILE_TYPE_DIRECTORY) { g_object_unref(inf); continue; } } /* virtual folders may return children not within them */ dir = fm_path_new_for_gfile(g_file_enumerator_get_container(enu)); if (fm_path_equal(job->dir_path, dir)) sub = fm_path_new_child(job->dir_path, g_file_info_get_name(inf)); else sub = fm_path_new_child(dir, g_file_info_get_name(inf)); child = g_file_get_child(g_file_enumerator_get_container(enu), g_file_info_get_name(inf)); if (g_file_info_get_file_type(inf) == G_FILE_TYPE_DIRECTORY) /* for dir: check if its FS is R/O and set attr. into inf */ _fm_file_info_job_update_fs_readonly(child, inf, NULL, NULL); fi = fm_file_info_new_from_g_file_data(child, inf, sub); fm_path_unref(sub); fm_path_unref(dir); g_object_unref(child); fm_dir_list_job_add_found_file(job, fi); fm_file_info_unref(fi); } else { if(err) { FmJobErrorAction act = fm_job_emit_error(fmjob, err, FM_JOB_ERROR_MILD); g_error_free(err); /* FM_JOB_RETRY is not supported. */ if(act == FM_JOB_ABORT) fm_job_cancel(fmjob); } /* otherwise it's EOL */ break; } g_object_unref(inf); } g_file_enumerator_close(enu, NULL, &err); g_object_unref(enu); } else { fm_job_emit_error(fmjob, err, FM_JOB_ERROR_CRITICAL); g_error_free(err); return FALSE; } return TRUE; }
static gboolean fm_dir_list_job_run_posix(FmDirListJob* job) { FmJob* fmjob = FM_JOB(job); FmFileInfo* fi; GError *err = NULL; char* path_str; GDir* dir; path_str = fm_path_to_str(job->dir_path); fi = _new_info_for_native_file(job, job->dir_path, path_str, NULL); if(fi) { if(! fm_file_info_is_dir(fi)) { err = g_error_new(G_IO_ERROR, G_IO_ERROR_NOT_DIRECTORY, _("The specified directory '%s' is not valid"), path_str); fm_file_info_unref(fi); fm_job_emit_error(fmjob, err, FM_JOB_ERROR_CRITICAL); g_error_free(err); g_free(path_str); return FALSE; } job->dir_fi = fi; } else { err = g_error_new(G_IO_ERROR, G_IO_ERROR_NOT_DIRECTORY, _("The specified directory '%s' is not valid"), path_str); fm_job_emit_error(fmjob, err, FM_JOB_ERROR_CRITICAL); g_error_free(err); g_free(path_str); return FALSE; } dir = g_dir_open(path_str, 0, &err); if( dir ) { const char* name; GString* fpath = g_string_sized_new(4096); int dir_len = strlen(path_str); g_string_append_len(fpath, path_str, dir_len); if(fpath->str[dir_len-1] != '/') { g_string_append_c(fpath, '/'); ++dir_len; } while( ! fm_job_is_cancelled(fmjob) && (name = g_dir_read_name(dir)) ) { FmPath* new_path; g_string_truncate(fpath, dir_len); g_string_append(fpath, name); if(job->flags & FM_DIR_LIST_JOB_DIR_ONLY) /* if we only want directories */ { struct stat st; /* FIXME: this results in an additional stat() call, which is inefficient */ if(stat(fpath->str, &st) == -1 || !S_ISDIR(st.st_mode)) continue; } new_path = fm_path_new_child(job->dir_path, name); _retry: fi = _new_info_for_native_file(job, new_path, fpath->str, &err); if (fi == NULL) /* we got a damaged file */ { FmJobErrorAction act = fm_job_emit_error(fmjob, err, FM_JOB_ERROR_MILD); GFile *gf; GFileInfo *inf; gchar *disp_basename; g_error_free(err); err = NULL; if(act == FM_JOB_RETRY) goto _retry; /* bug #3615271: Damaged mountpoint isn't shown let make a simple file info then */ inf = g_file_info_new(); gf = fm_path_to_gfile(new_path); g_file_info_set_file_type(inf, G_FILE_TYPE_UNKNOWN); g_file_info_set_name(inf, name); disp_basename = g_filename_display_basename(fpath->str); g_file_info_set_display_name(inf, disp_basename); g_free(disp_basename); g_file_info_set_content_type(inf, "inode/x-corrupted"); fi = fm_file_info_new_from_g_file_data(gf, inf, new_path); g_object_unref(inf); g_object_unref(gf); } fm_dir_list_job_add_found_file(job, fi); fm_file_info_unref(fi); fm_path_unref(new_path); } g_string_free(fpath, TRUE); g_dir_close(dir); } else { fm_job_emit_error(fmjob, err, FM_JOB_ERROR_CRITICAL); g_error_free(err); } g_free(path_str); return TRUE; }
static void fm_folder_finalize(GObject *object) { FmFolder *self; g_return_if_fail(object != NULL); g_return_if_fail(FM_IS_FOLDER(object)); self = FM_FOLDER(object); if(self->job) { g_signal_handlers_disconnect_by_func(self->job, on_job_finished, self); g_signal_handlers_disconnect_by_func(self->job, on_job_err, self); fm_job_cancel(FM_JOB(self->job)); /* FIXME: is this ok? */ /* the job will be freed automatically in idle handler. */ } if(self->pending_jobs) { GSList* l; for(l = self->pending_jobs;l;l=l->next) { FmJob* job = FM_JOB(l->data); g_signal_handlers_disconnect_by_func(job, on_job_finished, self); fm_job_cancel(job); /* the job will be freed automatically in idle handler. */ } } /* remove from hash table */ g_hash_table_remove(hash, self->dir_path); if(self->dir_path) fm_path_unref(self->dir_path); if(self->dir_fi) fm_file_info_unref(self->dir_fi); if(self->gf) g_object_unref(self->gf); if(self->mon) { g_signal_handlers_disconnect_by_func(self->mon, on_folder_changed, self); g_object_unref(self->mon); } if(self->idle_handler) { g_source_remove(self->idle_handler); if(self->files_to_add) { g_slist_foreach(self->files_to_add, (GFunc)g_free, NULL); g_slist_free(self->files_to_add); } if(self->files_to_update) { g_slist_foreach(self->files_to_update, (GFunc)g_free, NULL); g_slist_free(self->files_to_update); } if(self->files_to_del) g_slist_free(self->files_to_del); } fm_list_unref(self->files); if (G_OBJECT_CLASS(fm_folder_parent_class)->finalize) (* G_OBJECT_CLASS(fm_folder_parent_class)->finalize)(object); }
ExecFileDialog::~ExecFileDialog() { delete ui; if(fileInfo_) fm_file_info_unref(fileInfo_); }