// // fiv-io-model.c: filesystem // // Copyright (c) 2021 - 2023, Přemysl Eric Janouch // // Permission to use, copy, modify, and/or distribute this software for any // purpose with or without fee is hereby granted. // // THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES // WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF // MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY // SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES // WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. // #include "fiv-io.h" #include "fiv-io-model.h" #include "xdg.h" GType fiv_io_model_sort_get_type(void) { static gsize guard; if (g_once_init_enter(&guard)) { #define XX(name) {FIV_IO_MODEL_SORT_ ## name, \ "FIV_IO_MODEL_SORT_" #name, #name}, static const GEnumValue values[] = {FIV_IO_MODEL_SORTS(XX) {}}; #undef XX GType type = g_enum_register_static( g_intern_static_string("FivIoModelSort"), values); g_once_init_leave(&guard, type); } return guard; } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - G_DEFINE_BOXED_TYPE(FivIoModelEntry, fiv_io_model_entry, fiv_io_model_entry_ref, fiv_io_model_entry_unref) FivIoModelEntry * fiv_io_model_entry_ref(FivIoModelEntry *self) { return g_rc_box_acquire(self); } void fiv_io_model_entry_unref(FivIoModelEntry *self) { g_rc_box_release(self); } static size_t entry_strsize(const char *string) { if (!string) return 0; return strlen(string) + 1; } static char * entry_strappend(char **p, const char *string, size_t size) { if (!string) return NULL; char *destination = memcpy(*p, string, size); *p += size; return destination; } // See model_load_attributes for a (superset of a) list of required attributes. static FivIoModelEntry * entry_new(GFile *file, GFileInfo *info) { gchar *uri = g_file_get_uri(file); const gchar *target_uri = g_file_info_get_attribute_string( info, G_FILE_ATTRIBUTE_STANDARD_TARGET_URI); const gchar *display_name = g_file_info_get_display_name(info); // TODO(p): Make it possible to use g_utf8_collate_key() instead, // which does not use natural sorting. gchar *parse_name = g_file_get_parse_name(file); gchar *collate_key = g_utf8_collate_key_for_filename(parse_name, -1); g_free(parse_name); // The entries are immutable. Packing them into the structure // should help memory usage as well as performance. size_t size_uri = entry_strsize(uri); size_t size_target_uri = entry_strsize(target_uri); size_t size_display_name = entry_strsize(display_name); size_t size_collate_key = entry_strsize(collate_key); FivIoModelEntry *entry = g_rc_box_alloc0(sizeof *entry + size_uri + size_target_uri + size_display_name + size_collate_key); gchar *p = (gchar *) entry + sizeof *entry; entry->uri = entry_strappend(&p, uri, size_uri); entry->target_uri = entry_strappend(&p, target_uri, size_target_uri); entry->display_name = entry_strappend(&p, display_name, size_display_name); entry->collate_key = entry_strappend(&p, collate_key, size_collate_key); entry->filesize = (guint64) g_file_info_get_size(info); GDateTime *mtime = g_file_info_get_modification_date_time(info); if (mtime) { entry->mtime_msec = g_date_time_to_unix(mtime) * 1000 + g_date_time_get_microsecond(mtime) / 1000; g_date_time_unref(mtime); } g_free(uri); g_free(collate_key); return entry; } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - struct _FivIoModel { GObject parent_instance; GPatternSpec **supported_patterns; GFile *directory; ///< Currently loaded directory GFileMonitor *monitor; ///< "directory" monitoring GPtrArray *subdirs; ///< "directory" contents GPtrArray *files; ///< "directory" contents FivIoModelSort sort_field; ///< How to sort gboolean sort_descending; ///< Whether to sort in reverse gboolean filtering; ///< Only show non-hidden, supported }; G_DEFINE_TYPE(FivIoModel, fiv_io_model, G_TYPE_OBJECT) enum { PROP_FILTERING = 1, PROP_SORT_FIELD, PROP_SORT_DESCENDING, N_PROPERTIES }; static GParamSpec *model_properties[N_PROPERTIES]; enum { RELOADED, FILES_CHANGED, SUBDIRECTORIES_CHANGED, LAST_SIGNAL, }; // Globals are, sadly, the canonical way of storing signal numbers. static guint model_signals[LAST_SIGNAL]; // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static GPtrArray * model_entry_array_new(void) { return g_ptr_array_new_with_free_func( (GDestroyNotify) fiv_io_model_entry_unref); } #if !GLIB_CHECK_VERSION(2, 70, 0) #define g_pattern_spec_match g_pattern_match #endif static gboolean model_supports(FivIoModel *self, const char *filename) { gchar *utf8 = g_filename_to_utf8(filename, -1, NULL, NULL, NULL); if (!utf8) return FALSE; gchar *lc = g_utf8_strdown(utf8, -1); gsize lc_length = strlen(lc); gchar *reversed = g_utf8_strreverse(lc, lc_length); g_free(utf8); // fnmatch() uses the /locale encoding/, and isn't present on Windows. // TODO(p): Consider using g_file_info_get_display_name() for direct UTF-8. gboolean result = FALSE; for (GPatternSpec **p = self->supported_patterns; *p; p++) if ((result = g_pattern_spec_match(*p, lc_length, lc, reversed))) break; g_free(lc); g_free(reversed); return result; } static inline int model_compare_entries(FivIoModel *self, const FivIoModelEntry *entry1, GFile *file1, const FivIoModelEntry *entry2, GFile *file2) { if (g_file_has_prefix(file1, file2)) return +1; if (g_file_has_prefix(file2, file1)) return -1; int result = 0; switch (self->sort_field) { case FIV_IO_MODEL_SORT_MTIME: result -= entry1->mtime_msec < entry2->mtime_msec; result += entry1->mtime_msec > entry2->mtime_msec; if (result != 0) break; // Fall-through case FIV_IO_MODEL_SORT_NAME: case FIV_IO_MODEL_SORT_COUNT: result = strcmp(entry1->collate_key, entry2->collate_key); } return self->sort_descending ? -result : +result; } static gint model_compare(gconstpointer a, gconstpointer b, gpointer user_data) { const FivIoModelEntry *entry1 = *(const FivIoModelEntry **) a; const FivIoModelEntry *entry2 = *(const FivIoModelEntry **) b; GFile *file1 = g_file_new_for_uri(entry1->uri); GFile *file2 = g_file_new_for_uri(entry2->uri); int result = model_compare_entries(user_data, entry1, file1, entry2, file2); g_object_unref(file1); g_object_unref(file2); return result; } static const char *model_load_attributes = G_FILE_ATTRIBUTE_STANDARD_TYPE "," G_FILE_ATTRIBUTE_STANDARD_NAME "," G_FILE_ATTRIBUTE_STANDARD_SIZE "," G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME "," G_FILE_ATTRIBUTE_STANDARD_TARGET_URI "," G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN "," G_FILE_ATTRIBUTE_TIME_MODIFIED "," G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC; static GPtrArray * model_decide_placement( FivIoModel *self, GFileInfo *info, GPtrArray *subdirs, GPtrArray *files) { if (self->filtering && g_file_info_get_is_hidden(info)) return NULL; if (g_file_info_get_file_type(info) == G_FILE_TYPE_DIRECTORY) return subdirs; if (!self->filtering || model_supports(self, g_file_info_get_name(info))) return files; return NULL; } static gboolean model_reload_to(FivIoModel *self, GFile *directory, GPtrArray *subdirs, GPtrArray *files, GError **error) { if (subdirs) g_ptr_array_set_size(subdirs, 0); if (files) g_ptr_array_set_size(files, 0); GFileEnumerator *enumerator = g_file_enumerate_children( directory, model_load_attributes, G_FILE_QUERY_INFO_NONE, NULL, error); if (!enumerator) return FALSE; GFileInfo *info = NULL; GFile *child = NULL; GError *e = NULL; while (TRUE) { if (!g_file_enumerator_iterate(enumerator, &info, &child, NULL, &e) && e) { g_warning("%s", e->message); g_clear_error(&e); continue; } if (!info) break; GPtrArray *target = model_decide_placement(self, info, subdirs, files); if (target) g_ptr_array_add(target, entry_new(child, info)); } g_object_unref(enumerator); if (subdirs) g_ptr_array_sort_with_data(subdirs, model_compare, self); if (files) g_ptr_array_sort_with_data(files, model_compare, self); return TRUE; } static gboolean model_reload(FivIoModel *self, GError **error) { // Note that this will clear all entries on failure. gboolean result = model_reload_to( self, self->directory, self->subdirs, self->files, error); g_signal_emit(self, model_signals[RELOADED], 0); return result; } static void model_resort(FivIoModel *self) { g_ptr_array_sort_with_data(self->subdirs, model_compare, self); g_ptr_array_sort_with_data(self->files, model_compare, self); g_signal_emit(self, model_signals[RELOADED], 0); } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static gint model_find(const GPtrArray *target, GFile *file, FivIoModelEntry **entry) { for (guint i = 0; i < target->len; i++) { FivIoModelEntry *e = target->pdata[i]; GFile *f = g_file_new_for_uri(e->uri); gboolean match = g_file_equal(f, file); g_object_unref(f); if (match) { *entry = e; return i; } } return -1; } enum monitor_event { MONITOR_NONE, MONITOR_CHANGING, MONITOR_RENAMING, MONITOR_REMOVING, MONITOR_ADDING }; static void monitor_apply(enum monitor_event event, GPtrArray *target, int index, FivIoModelEntry *new_entry) { g_return_if_fail(event != MONITOR_CHANGING || index >= 0); if (event == MONITOR_RENAMING && index < 0) // The file used to be filtered out but isn't anymore. event = MONITOR_ADDING; else if (!new_entry && index >= 0) // The file wasn't filtered out but now it is. event = MONITOR_REMOVING; if (event == MONITOR_CHANGING) { fiv_io_model_entry_unref(target->pdata[index]); target->pdata[index] = fiv_io_model_entry_ref(new_entry); } if (event == MONITOR_REMOVING || event == MONITOR_RENAMING) g_ptr_array_remove_index(target, index); if (event == MONITOR_RENAMING || event == MONITOR_ADDING) g_ptr_array_add(target, fiv_io_model_entry_ref(new_entry)); } static void on_monitor_changed(G_GNUC_UNUSED GFileMonitor *monitor, GFile *file, GFile *other_file, GFileMonitorEvent event_type, gpointer user_data) { FivIoModel *self = user_data; FivIoModelEntry *old_entry = NULL; gint files_index = model_find(self->files, file, &old_entry); gint subdirs_index = model_find(self->subdirs, file, &old_entry); enum monitor_event event = MONITOR_NONE; GFile *new_entry_file = NULL; switch (event_type) { case G_FILE_MONITOR_EVENT_CHANGED: case G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED: event = MONITOR_CHANGING; new_entry_file = file; break; case G_FILE_MONITOR_EVENT_RENAMED: event = MONITOR_RENAMING; new_entry_file = other_file; break; case G_FILE_MONITOR_EVENT_DELETED: case G_FILE_MONITOR_EVENT_MOVED_OUT: event = MONITOR_REMOVING; break; case G_FILE_MONITOR_EVENT_CREATED: case G_FILE_MONITOR_EVENT_MOVED_IN: event = MONITOR_ADDING; old_entry = NULL; new_entry_file = file; break; case G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT: // TODO(p): Figure out if we can't make use of _CHANGES_DONE_HINT. case G_FILE_MONITOR_EVENT_PRE_UNMOUNT: case G_FILE_MONITOR_EVENT_UNMOUNTED: // TODO(p): Figure out how to handle _UNMOUNTED sensibly. case G_FILE_MONITOR_EVENT_MOVED: return; } FivIoModelEntry *new_entry = NULL; GPtrArray *new_target = NULL; if (new_entry_file) { GError *error = NULL; GFileInfo *info = g_file_query_info(new_entry_file, model_load_attributes, G_FILE_QUERY_INFO_NONE, NULL, &error); if (error) { g_debug("monitor: %s", error->message); g_error_free(error); goto run; } if ((new_target = model_decide_placement(self, info, self->subdirs, self->files))) new_entry = entry_new(new_entry_file, info); g_object_unref(info); if ((files_index != -1 && new_target == self->subdirs) || (subdirs_index != -1 && new_target == self->files)) { g_debug("monitor: ignoring transfer between files and subdirs"); goto out; } } run: // Keep a reference alive so that signal handlers see the new arrays. if (old_entry) fiv_io_model_entry_ref(old_entry); if (files_index != -1 || new_target == self->files) { monitor_apply(event, self->files, files_index, new_entry); g_signal_emit(self, model_signals[FILES_CHANGED], 0, old_entry, new_entry); } if (subdirs_index != -1 || new_target == self->subdirs) { monitor_apply(event, self->subdirs, subdirs_index, new_entry); g_signal_emit(self, model_signals[SUBDIRECTORIES_CHANGED], 0, old_entry, new_entry); } // NOTE: It would make sense to do // g_ptr_array_sort_with_data(self->{files,subdirs}, model_compare, self); // but then the iteration behaviour of fiv.c would differ from what's shown // in the browser. Perhaps we need to use an index-based, fully-synchronized // interface similar to GListModel::items-changed. if (old_entry) fiv_io_model_entry_unref(old_entry); out: if (new_entry) fiv_io_model_entry_unref(new_entry); } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // This would be more efficient iteratively, but it's not that important. static GFile * model_last_deep_subdirectory(FivIoModel *self, GFile *directory) { GFile *result = NULL; GPtrArray *subdirs = model_entry_array_new(); if (!model_reload_to(self, directory, subdirs, NULL, NULL)) goto out; if (subdirs->len) { FivIoModelEntry *entry = g_ptr_array_index(subdirs, subdirs->len - 1); GFile *last = g_file_new_for_uri(entry->uri); result = model_last_deep_subdirectory(self, last); g_object_unref(last); } else { result = g_object_ref(directory); } out: g_ptr_array_free(subdirs, TRUE); return result; } GFile * fiv_io_model_get_previous_directory(FivIoModel *self) { g_return_val_if_fail(FIV_IS_IO_MODEL(self), NULL); GFile *parent_directory = g_file_get_parent(self->directory); if (!parent_directory) return NULL; GFile *result = NULL; GPtrArray *subdirs = model_entry_array_new(); if (!model_reload_to(self, parent_directory, subdirs, NULL, NULL)) goto out; for (gsize i = 0; i < subdirs->len; i++) { FivIoModelEntry *entry = g_ptr_array_index(subdirs, i); GFile *file = g_file_new_for_uri(entry->uri); if (g_file_equal(file, self->directory)) { g_object_unref(file); break; } g_clear_object(&result); result = file; } if (result) { GFile *last = model_last_deep_subdirectory(self, result); g_object_unref(result); result = last; } else { result = g_object_ref(parent_directory); } out: g_object_unref(parent_directory); g_ptr_array_free(subdirs, TRUE); return result; } // This would be more efficient iteratively, but it's not that important. static GFile * model_next_directory_within_parents(FivIoModel *self, GFile *directory) { GFile *parent_directory = g_file_get_parent(directory); if (!parent_directory) return NULL; GFile *result = NULL; GPtrArray *subdirs = model_entry_array_new(); if (!model_reload_to(self, parent_directory, subdirs, NULL, NULL)) goto out; gboolean found_self = FALSE; for (gsize i = 0; i < subdirs->len; i++) { FivIoModelEntry *entry = g_ptr_array_index(subdirs, i); result = g_file_new_for_uri(entry->uri); if (found_self) goto out; found_self = g_file_equal(result, directory); g_clear_object(&result); } if (!result) result = model_next_directory_within_parents(self, parent_directory); out: g_object_unref(parent_directory); g_ptr_array_free(subdirs, TRUE); return result; } GFile * fiv_io_model_get_next_directory(FivIoModel *self) { g_return_val_if_fail(FIV_IS_IO_MODEL(self), NULL); if (self->subdirs->len) { FivIoModelEntry *entry = g_ptr_array_index(self->subdirs, 0); return g_file_new_for_uri(entry->uri); } return model_next_directory_within_parents(self, self->directory); } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static void fiv_io_model_finalize(GObject *gobject) { FivIoModel *self = FIV_IO_MODEL(gobject); for (GPatternSpec **p = self->supported_patterns; *p; p++) g_pattern_spec_free(*p); g_free(self->supported_patterns); g_clear_object(&self->directory); g_clear_object(&self->monitor); g_ptr_array_free(self->subdirs, TRUE); g_ptr_array_free(self->files, TRUE); G_OBJECT_CLASS(fiv_io_model_parent_class)->finalize(gobject); } static void fiv_io_model_get_property( GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { FivIoModel *self = FIV_IO_MODEL(object); switch (property_id) { case PROP_FILTERING: g_value_set_boolean(value, self->filtering); break; case PROP_SORT_FIELD: g_value_set_enum(value, self->sort_field); break; case PROP_SORT_DESCENDING: g_value_set_boolean(value, self->sort_descending); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); } } static void fiv_io_model_set_property( GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { FivIoModel *self = FIV_IO_MODEL(object); switch (property_id) { case PROP_FILTERING: if (self->filtering != g_value_get_boolean(value)) { self->filtering = !self->filtering; g_object_notify_by_pspec(object, model_properties[property_id]); (void) model_reload(self, NULL /* error */); } break; case PROP_SORT_FIELD: if ((int) self->sort_field != g_value_get_enum(value)) { self->sort_field = g_value_get_enum(value); g_object_notify_by_pspec(object, model_properties[property_id]); model_resort(self); } break; case PROP_SORT_DESCENDING: if (self->sort_descending != g_value_get_boolean(value)) { self->sort_descending = !self->sort_descending; g_object_notify_by_pspec(object, model_properties[property_id]); model_resort(self); } break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); } } static void fiv_io_model_class_init(FivIoModelClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS(klass); object_class->get_property = fiv_io_model_get_property; object_class->set_property = fiv_io_model_set_property; object_class->finalize = fiv_io_model_finalize; model_properties[PROP_FILTERING] = g_param_spec_boolean( "filtering", "Filtering", "Only show non-hidden, supported entries", TRUE, G_PARAM_READWRITE); model_properties[PROP_SORT_FIELD] = g_param_spec_enum( "sort-field", "Sort field", "Sort order", FIV_TYPE_IO_MODEL_SORT, FIV_IO_MODEL_SORT_NAME, G_PARAM_READWRITE); model_properties[PROP_SORT_DESCENDING] = g_param_spec_boolean( "sort-descending", "Sort descending", "Use reverse sort order", FALSE, G_PARAM_READWRITE); g_object_class_install_properties( object_class, N_PROPERTIES, model_properties); // All entries might have changed. model_signals[RELOADED] = g_signal_new("reloaded", G_TYPE_FROM_CLASS(klass), 0, 0, NULL, NULL, NULL, G_TYPE_NONE, 0); model_signals[FILES_CHANGED] = g_signal_new("files-changed", G_TYPE_FROM_CLASS(klass), 0, 0, NULL, NULL, NULL, G_TYPE_NONE, 2, FIV_TYPE_IO_MODEL_ENTRY, FIV_TYPE_IO_MODEL_ENTRY); model_signals[SUBDIRECTORIES_CHANGED] = g_signal_new("subdirectories-changed", G_TYPE_FROM_CLASS(klass), 0, 0, NULL, NULL, NULL, G_TYPE_NONE, 2, FIV_TYPE_IO_MODEL_ENTRY, FIV_TYPE_IO_MODEL_ENTRY); } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static void fiv_io_model_init(FivIoModel *self) { self->filtering = TRUE; char **types = fiv_io_all_supported_media_types(); char **globs = extract_mime_globs((const char **) types); g_strfreev(types); gsize n = g_strv_length(globs); self->supported_patterns = g_malloc0_n(n + 1, sizeof *self->supported_patterns); while (n--) self->supported_patterns[n] = g_pattern_spec_new(globs[n]); g_strfreev(globs); self->files = model_entry_array_new(); self->subdirs = model_entry_array_new(); } gboolean fiv_io_model_open(FivIoModel *self, GFile *directory, GError **error) { g_return_val_if_fail(FIV_IS_IO_MODEL(self), FALSE); g_return_val_if_fail(G_IS_FILE(directory), FALSE); g_clear_object(&self->directory); g_clear_object(&self->monitor); self->directory = g_object_ref(directory); GError *e = NULL; if ((self->monitor = g_file_monitor_directory( directory, G_FILE_MONITOR_WATCH_MOVES, NULL, &e))) { g_signal_connect(self->monitor, "changed", G_CALLBACK(on_monitor_changed), self); } else { g_debug("directory monitoring failed: %s", e->message); g_error_free(e); } return model_reload(self, error); } GFile * fiv_io_model_get_location(FivIoModel *self) { g_return_val_if_fail(FIV_IS_IO_MODEL(self), NULL); return self->directory; } FivIoModelEntry *const * fiv_io_model_get_files(FivIoModel *self, gsize *len) { *len = self->files->len; return (FivIoModelEntry *const *) self->files->pdata; } FivIoModelEntry *const * fiv_io_model_get_subdirs(FivIoModel *self, gsize *len) { *len = self->subdirs->len; return (FivIoModelEntry *const *) self->subdirs->pdata; }