static bool folder_cb(const char *directory, rgui_file_enum_cb_t file_cb, void *userdata, void *ctx) { bool core_chooser = (userdata) ? *(rgui_file_type_t *)userdata == RGUI_SETTINGS_CORE : false; if (!*directory) { #ifdef HW_RVL file_cb(ctx, "sd:", RGUI_FILE_DEVICE, 0); file_cb(ctx, "usb:", RGUI_FILE_DEVICE, 0); #endif file_cb(ctx, "carda:", RGUI_FILE_DEVICE, 0); file_cb(ctx, "cardb:", RGUI_FILE_DEVICE, 0); return true; } #ifdef HW_RVL LWP_MutexLock(gx_device_mutex); int dev = gx_get_device_from_path(directory); if (dev != -1 && !gx_devices[dev].mounted && gx_devices[dev].interface->isInserted()) fatMountSimple(gx_devices[dev].name, gx_devices[dev].interface); LWP_MutexUnlock(gx_device_mutex); #endif char exts[256]; if (core_chooser) strlcpy(exts, "dol|DOL", sizeof(exts)); else strlcpy(exts, rarch_console_get_rom_ext(), sizeof(exts)); struct string_list *ext_list = string_split(exts, "|"); char _dir[PATH_MAX]; snprintf(_dir, sizeof(_dir), "%s/", directory); DIR *dir = opendir(_dir); if (!dir) return false; struct dirent *entry; while ((entry = readdir(dir))) { char stat_path[PATH_MAX]; const char *file_ext = path_get_extension(entry->d_name); snprintf(stat_path, sizeof(stat_path), "%s/%s", directory, entry->d_name); bool is_dir; #ifdef _DIRENT_HAVE_D_TYPE is_dir = (entry->d_type == DT_DIR); if (entry->d_type != DT_REG && !is_dir) continue; #else struct stat st; if (stat(stat_path, &st) < 0) continue; is_dir = S_ISDIR(st.st_mode); if (!S_ISREG(st.st_mode) && !is_dir) continue; #endif if (core_chooser && (is_dir || strcasecmp(entry->d_name, default_paths.salamander_file) == 0)) continue; if (!is_dir && ext_list && !string_list_find_elem_prefix(ext_list, ".", file_ext)) continue; file_cb(ctx, entry->d_name, is_dir ? RGUI_FILE_DIRECTORY : RGUI_FILE_PLAIN, 0); } closedir(dir); string_list_free(ext_list); return true; }
int menu_entries_parse_list( file_list_t *list, file_list_t *menu_list, const char *dir, const char *label, unsigned type, unsigned default_type_plain, const char *exts, rarch_setting_t *setting) { size_t i, list_size; bool path_is_compressed, push_dir; int device = 0; struct string_list *str_list = NULL; settings_t *settings = config_get_ptr(); global_t *global = global_get_ptr(); (void)device; if (!list || !menu_list) return -1; menu_list_clear(list); if (!*dir) { menu_entries_parse_drive_list(list); menu_driver_populate_entries(dir, label, type); return 0; } #if defined(GEKKO) && defined(HW_RVL) slock_lock(gx_device_mutex); device = gx_get_device_from_path(dir); if (device != -1 && !gx_devices[device].mounted && gx_devices[device].interface->isInserted()) fatMountSimple(gx_devices[device].name, gx_devices[device].interface); slock_unlock(gx_device_mutex); #endif path_is_compressed = path_is_compressed_file(dir); push_dir = (setting && setting->browser_selection_type == ST_DIR); if (path_is_compressed) str_list = compressed_file_list_new(dir,exts); else str_list = dir_list_new(dir, settings->menu.navigation.browser.filter.supported_extensions_enable ? exts : NULL, true); if (push_dir) menu_list_push(list, "<Use this directory>", "", MENU_FILE_USE_DIRECTORY, 0); if (!str_list) return -1; dir_list_sort(str_list, true); list_size = str_list->size; for (i = 0; i < str_list->size; i++) { bool is_dir; const char *path = NULL; menu_file_type_t file_type = MENU_FILE_NONE; switch (str_list->elems[i].attr.i) { case RARCH_DIRECTORY: file_type = MENU_FILE_DIRECTORY; break; case RARCH_COMPRESSED_ARCHIVE: file_type = MENU_FILE_CARCHIVE; break; case RARCH_COMPRESSED_FILE_IN_ARCHIVE: file_type = MENU_FILE_IN_CARCHIVE; break; case RARCH_PLAIN_FILE: default: if (!strcmp(label, "detect_core_list")) { if (path_is_compressed_file(str_list->elems[i].data)) { /* in case of deferred_core_list we have to interpret * every archive as an archive to disallow instant loading */ file_type = MENU_FILE_CARCHIVE; break; } } file_type = (menu_file_type_t)default_type_plain; break; } is_dir = (file_type == MENU_FILE_DIRECTORY); if (push_dir && !is_dir) continue; /* Need to preserve slash first time. */ path = str_list->elems[i].data; if (*dir && !path_is_compressed) path = path_basename(path); #ifdef HAVE_LIBRETRO_MANAGEMENT #ifdef RARCH_CONSOLE if (!strcmp(label, "core_list") && (is_dir || strcasecmp(path, SALAMANDER_FILE) == 0)) continue; #endif #endif /* Push type further down in the chain. * Needed for shader manager currently. */ if (!strcmp(label, "core_list")) { /* Compressed cores are unsupported */ if (file_type == MENU_FILE_CARCHIVE) continue; menu_list_push(list, path, "", is_dir ? MENU_FILE_DIRECTORY : MENU_FILE_CORE, 0); } else menu_list_push(list, path, "", file_type, 0); } string_list_free(str_list); if (!strcmp(label, "core_list")) { driver_t *driver = driver_get_ptr(); menu_list_get_last_stack(driver->menu->menu_list, &dir, NULL, NULL); list_size = file_list_get_size(list); for (i = 0; i < list_size; i++) { char core_path[PATH_MAX_LENGTH], display_name[PATH_MAX_LENGTH]; const char *path = NULL; menu_list_get_at_offset(list, i, &path, NULL, &type); if (type != MENU_FILE_CORE) continue; fill_pathname_join(core_path, dir, path, sizeof(core_path)); if (global->core_info && core_info_list_get_display_name(global->core_info, core_path, display_name, sizeof(display_name))) menu_list_set_alt_at_offset(list, i, display_name); } menu_list_sort_on_alt(list); } menu_list_populate_generic(list, dir, label, type); return 0; }