void path_fill_names(void) { global_t *global = global_get_ptr(); path_init_savefile_internal(); if (global) bsv_movie_set_path(global->name.savefile); if (string_is_empty(path_main_basename)) return; if (global) { if (string_is_empty(global->name.ups)) fill_pathname_noext(global->name.ups, path_main_basename, file_path_str(FILE_PATH_UPS_EXTENSION), sizeof(global->name.ups)); if (string_is_empty(global->name.bps)) fill_pathname_noext(global->name.bps, path_main_basename, file_path_str(FILE_PATH_BPS_EXTENSION), sizeof(global->name.bps)); if (string_is_empty(global->name.ips)) fill_pathname_noext(global->name.ips, path_main_basename, file_path_str(FILE_PATH_IPS_EXTENSION), sizeof(global->name.ips)); } }
static void menu_action_setting_disp_set_label_playlist_associations(file_list_t* list, unsigned *w, unsigned type, unsigned i, const char *label, char *s, size_t len, const char *entry_label, const char *path, char *s2, size_t len2) { char playlist_name_with_ext[255]; bool found_matching_core_association = false; settings_t *settings = config_get_ptr(); struct string_list *str_list = string_split(settings->arrays.playlist_names, ";"); struct string_list *str_list2 = string_split(settings->arrays.playlist_cores, ";"); strlcpy(s2, path, len2); playlist_name_with_ext[0] = '\0'; *s = '\0'; *w = 19; fill_pathname_noext(playlist_name_with_ext, path, file_path_str(FILE_PATH_LPL_EXTENSION), sizeof(playlist_name_with_ext)); for (i = 0; i < str_list->size; i++) { if (string_is_equal(str_list->elems[i].data, playlist_name_with_ext)) { if (str_list->size != str_list2->size) break; if (!str_list2->elems[i].data) break; found_matching_core_association = true; strlcpy(s, str_list2->elems[i].data, len); } } string_list_free(str_list); string_list_free(str_list2); if (string_is_equal(s, file_path_str(FILE_PATH_DETECT)) || !found_matching_core_association) strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NOT_AVAILABLE), len); else { char buf[PATH_MAX_LENGTH]; core_info_list_t *list = NULL; core_info_get_list(&list); if (core_info_list_get_display_name(list, s, buf, sizeof(buf))) strlcpy(s, buf, len); } strlcpy(s2, path, len2); }
/** * menu_content_load_from_playlist: * @playlist : Playlist handle. * @idx : Index in playlist. * * Initializes core and loads content based on playlist entry. **/ bool menu_content_playlist_load(menu_content_ctx_playlist_info_t *info) { playlist_t *playlist = NULL; const char *path = NULL; if (!info) return false; playlist = (playlist_t*)info->data; if (!playlist) return false; playlist_get_index(playlist, info->idx, &path, NULL, NULL, NULL, NULL, NULL); if (!string_is_empty(path)) { unsigned i; bool valid_path = false; char *path_check = NULL; char *path_tolower = strdup(path); for (i = 0; i < strlen(path_tolower); ++i) path_tolower[i] = tolower(path_tolower[i]); if (strstr(path_tolower, file_path_str(FILE_PATH_ZIP_EXTENSION))) strstr(path_tolower, file_path_str(FILE_PATH_ZIP_EXTENSION))[4] = '\0'; else if (strstr(path_tolower, file_path_str(FILE_PATH_7Z_EXTENSION))) strstr(path_tolower, file_path_str(FILE_PATH_7Z_EXTENSION))[3] = '\0'; path_check = (char *) calloc(strlen(path_tolower) + 1, sizeof(char)); strncpy(path_check, path, strlen(path_tolower)); valid_path = path_is_valid(path_check); free(path_tolower); free(path_check); if (!valid_path) goto error; } return true; error: runloop_msg_queue_push("File could not be loaded from playlist.\n", 1, 100, true); return false; }
void input_config_get_bind_string(char *buf, const struct retro_keybind *bind, const struct retro_keybind *auto_bind, size_t size) { #ifndef RARCH_CONSOLE char key[64]; char keybuf[64]; key[0] = keybuf[0] = '\0'; #endif *buf = '\0'; if (bind->joykey != NO_BTN) input_config_get_bind_string_joykey(buf, "", bind, size); else if (bind->joyaxis != AXIS_NONE) input_config_get_bind_string_joyaxis(buf, "", bind, size); else if (auto_bind && auto_bind->joykey != NO_BTN) input_config_get_bind_string_joykey(buf, "Auto: ", auto_bind, size); else if (auto_bind && auto_bind->joyaxis != AXIS_NONE) input_config_get_bind_string_joyaxis(buf, "Auto: ", auto_bind, size); #ifndef RARCH_CONSOLE input_keymaps_translate_rk_to_str(bind->key, key, sizeof(key)); if (string_is_equal(key, file_path_str(FILE_PATH_NUL))) *key = '\0'; snprintf(keybuf, sizeof(keybuf), msg_hash_to_str(MENU_ENUM_LABEL_VALUE_INPUT_KEY), key); strlcat(buf, keybuf, size); #endif }
static config_file_t *core_info_list_iterate( struct string_list *contents, size_t i) { char info_path_base[PATH_MAX_LENGTH] = {0}; char info_path[PATH_MAX_LENGTH] = {0}; settings_t *settings = config_get_ptr(); if (!contents->elems[i].data) return NULL; fill_pathname_base_noext(info_path_base, contents->elems[i].data, sizeof(info_path_base)); #if defined(RARCH_MOBILE) || (defined(RARCH_CONSOLE) && !defined(PSP) && !defined(_3DS) && !defined(VITA)) char *substr = strrchr(info_path_base, '_'); if (substr) *substr = '\0'; #endif strlcat(info_path_base, file_path_str(FILE_PATH_CORE_INFO_EXTENSION), sizeof(info_path_base)); fill_pathname_join(info_path, (!string_is_empty(settings->path.libretro_info)) ? settings->path.libretro_info : settings->directory.libretro, info_path_base, sizeof(info_path)); return config_file_new(info_path); }
void RARCH_LOG_OUTPUT(const char *msg, ...) { va_list ap; va_start(ap, msg); RARCH_LOG_OUTPUT_V(file_path_str(FILE_PATH_LOG_INFO), msg, ap); va_end(ap); }
void ozone_init_horizontal_list(ozone_handle_t *ozone) { menu_displaylist_info_t info; settings_t *settings = config_get_ptr(); menu_displaylist_info_init(&info); info.list = ozone->horizontal_list; info.path = strdup( settings->paths.directory_playlist); info.label = strdup( msg_hash_to_str(MENU_ENUM_LABEL_CONTENT_COLLECTION_LIST)); info.exts = strdup( file_path_str(FILE_PATH_LPL_EXTENSION_NO_DOT)); info.type_default = FILE_TYPE_PLAIN; info.enum_idx = MENU_ENUM_LABEL_CONTENT_COLLECTION_LIST; if (settings->bools.menu_content_show_playlists && !string_is_empty(info.path)) { if (menu_displaylist_ctl(DISPLAYLIST_DATABASE_PLAYLISTS_HORIZONTAL, &info)) menu_displaylist_process(&info); } menu_displaylist_info_free(&info); }
static bool core_info_list_iterate( char *s, size_t len, struct string_list *contents, size_t i) { char info_path_base[PATH_MAX_LENGTH]; #if defined(RARCH_MOBILE) || (defined(RARCH_CONSOLE) && !defined(PSP) && !defined(_3DS) && !defined(VITA)) char *substr = NULL; #endif settings_t *settings = config_get_ptr(); if (!contents || !contents->elems[i].data) return false; info_path_base[0] = '\0'; fill_pathname_base_noext(info_path_base, contents->elems[i].data, sizeof(info_path_base)); #if defined(RARCH_MOBILE) || (defined(RARCH_CONSOLE) && !defined(PSP) && !defined(_3DS) && !defined(VITA) && !defined(HW_WUP)) substr = strrchr(info_path_base, '_'); if (substr) *substr = '\0'; #endif strlcat(info_path_base, file_path_str(FILE_PATH_CORE_INFO_EXTENSION), sizeof(info_path_base)); fill_pathname_join(s, (!string_is_empty(settings->paths.path_libretro_info)) ? settings->paths.path_libretro_info : settings->paths.directory_libretro, info_path_base, len); return true; }
static int action_start_playlist_association(unsigned type, const char *label) { int found; char new_playlist_cores[PATH_MAX_LENGTH]; struct string_list *stnames = NULL; struct string_list *stcores = NULL; core_info_list_t *list = NULL; settings_t *settings = config_get_ptr(); const char *path = path_basename(label); core_info_get_list(&list); if (!list) return -1; new_playlist_cores[0] = '\0'; stnames = string_split(settings->arrays.playlist_names, ";"); stcores = string_split(settings->arrays.playlist_cores, ";"); found = string_list_find_elem(stnames, path); if (found) string_list_set(stcores, found-1, file_path_str(FILE_PATH_DETECT)); string_list_join_concat(new_playlist_cores, sizeof(new_playlist_cores), stcores, ";"); strlcpy(settings->arrays.playlist_cores, new_playlist_cores, sizeof(settings->arrays.playlist_cores)); string_list_free(stcores); string_list_free(stnames); return 0; }
void RARCH_ERR(const char *fmt, ...) { va_list ap; va_start(ap, fmt); RARCH_ERR_V(file_path_str(FILE_PATH_LOG_ERROR), fmt, ap); va_end(ap); }
void IfcPPReaderSTEP::loadModelFromFile( const std::wstring& file_path, shared_ptr<IfcPPModel>& target_model ) { // if file content needs to be loaded into a plain model, call resetModel() before loadModelFromFile std::wstring ext = file_path.substr( file_path.find_last_of( L"." ) + 1 ); if( boost::iequals( ext, "ifc" ) ) { // ok, nothing to do here } else if( boost::iequals( ext, "ifcXML" ) ) { // TODO: implement xml reader messageCallback( "ifcXML not yet implemented", StatusCallback::MESSAGE_TYPE_ERROR, __FUNC__ ); return; } else if( boost::iequals( ext, "ifcZIP" ) ) { // TODO: implement zip uncompress messageCallback( "ifcZIP not yet implemented", StatusCallback::MESSAGE_TYPE_ERROR, __FUNC__ ); return; } else { std::wstringstream strs; strs << "Unsupported file type: " << ext; messageCallback( strs.str().c_str(), StatusCallback::MESSAGE_TYPE_ERROR, __FUNC__ ); return; } // open file #ifdef _MSC_VER std::ifstream infile(file_path.c_str(), std::ifstream::in ); #else std::string file_path_str( file_path.begin(), file_path.end() ); std::ifstream infile(file_path_str.c_str(), std::ifstream::in ); #endif if( !infile.is_open() ) { std::wstringstream strs; strs << "Could not open file: " << file_path.c_str(); messageCallback( strs.str().c_str(), StatusCallback::MESSAGE_TYPE_ERROR, __FUNC__ ); return; } // get length of file content std::streampos file_size = infile.tellg(); infile.seekg( 0, std::ios::end ); file_size = infile.tellg() - file_size; infile.seekg( 0, std::ios::beg ); // read file content into string std::string buffer( (int)file_size, '\0' ); infile.read( &buffer[0], file_size ); infile.close(); loadModelFromString( buffer, target_model ); }
static int playlist_association_right(unsigned type, const char *label, bool wraparound) { char core_path[PATH_MAX_LENGTH]; char new_playlist_cores[PATH_MAX_LENGTH]; size_t i, next, found, current = 0; core_info_t *info = NULL; struct string_list *stnames = NULL; struct string_list *stcores = NULL; core_info_list_t *list = NULL; settings_t *settings = config_get_ptr(); const char *path = path_basename(label); core_info_get_list(&list); if (!list) return menu_cbs_exit(); core_path[0] = new_playlist_cores[0] = '\0'; stnames = string_split(settings->arrays.playlist_names, ";"); stcores = string_split(settings->arrays.playlist_cores, ";"); if (!menu_content_playlist_find_associated_core(path, core_path, sizeof(core_path))) strlcpy(core_path, file_path_str(FILE_PATH_DETECT), sizeof(core_path)); for (i = 0; i < list->count; i++) { core_info_t *info = core_info_get(list, i); if (string_is_equal(info->path, core_path)) current = i; } next = current + 1; if (next >= list->count) { if (wraparound) next = 0; else next = list->count-1; } info = core_info_get(list, next); found = string_list_find_elem(stnames, path); if (found && info) string_list_set(stcores, (unsigned)(found-1), info->path); string_list_join_concat(new_playlist_cores, sizeof(new_playlist_cores), stcores, ";"); strlcpy(settings->arrays.playlist_cores, new_playlist_cores, sizeof(settings->arrays.playlist_cores)); string_list_free(stnames); string_list_free(stcores); return 0; }
void RARCH_LOG(const char *fmt, ...) { va_list ap; if (!verbosity_is_enabled()) return; va_start(ap, fmt); RARCH_LOG_V(file_path_str(FILE_PATH_LOG_INFO), fmt, ap); va_end(ap); }
static void path_set_names(const char *path) { global_t *global = global_get_ptr(); path_set_basename(path); if (global) { if (!retroarch_override_setting_is_set(RARCH_OVERRIDE_SETTING_SAVE_PATH, NULL)) fill_pathname_noext(global->name.savefile, path_main_basename, file_path_str(FILE_PATH_SRM_EXTENSION), sizeof(global->name.savefile)); if (!retroarch_override_setting_is_set(RARCH_OVERRIDE_SETTING_STATE_PATH, NULL)) fill_pathname_noext(global->name.savestate, path_main_basename, file_path_str(FILE_PATH_STATE_EXTENSION), sizeof(global->name.savestate)); fill_pathname_noext(global->name.cheatfile, path_main_basename, file_path_str(FILE_PATH_CHT_EXTENSION), sizeof(global->name.cheatfile)); } path_set_redirect(); }
static void create_path_names(void) { char cwd[FILENAME_MAX]; int bootDeviceID; getcwd(cwd, sizeof(cwd)); bootDeviceID=getBootDeviceID(cwd); strlcpy(cwd, rootDevicePath(bootDeviceID), sizeof(cwd)); strcat(cwd, "RETROARCH"); strlcpy(eboot_path, cwd, sizeof(eboot_path)); strlcpy(g_defaults.dirs[DEFAULT_DIR_PORT], eboot_path, sizeof(g_defaults.dirs[DEFAULT_DIR_PORT])); strlcpy(user_path, eboot_path, sizeof(user_path)); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_CORE], g_defaults.dirs[DEFAULT_DIR_PORT], "CORES", sizeof(g_defaults.dirs[DEFAULT_DIR_CORE])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_CORE_INFO], g_defaults.dirs[DEFAULT_DIR_PORT], "INFO", sizeof(g_defaults.dirs[DEFAULT_DIR_CORE_INFO])); /* user data */ fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_CHEATS], user_path, "CHEATS", sizeof(g_defaults.dirs[DEFAULT_DIR_CHEATS])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_MENU_CONFIG], user_path, "CONFIG", sizeof(g_defaults.dirs[DEFAULT_DIR_MENU_CONFIG])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_CORE_ASSETS], user_path, "DOWNLOADS", sizeof(g_defaults.dirs[DEFAULT_DIR_CORE_ASSETS])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_PLAYLIST], user_path, "PLAYLISTS", sizeof(g_defaults.dirs[DEFAULT_DIR_PLAYLIST])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_REMAP], g_defaults.dirs[DEFAULT_DIR_MENU_CONFIG], "REMAPS", sizeof(g_defaults.dirs[DEFAULT_DIR_REMAP])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_SRAM], user_path, "SAVEFILES", sizeof(g_defaults.dirs[DEFAULT_DIR_SRAM])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_SAVESTATE], user_path, "SAVESTATES", sizeof(g_defaults.dirs[DEFAULT_DIR_SAVESTATE])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_SCREENSHOT], user_path, "SCREENSHOTS", sizeof(g_defaults.dirs[DEFAULT_DIR_SCREENSHOT])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_SYSTEM], user_path, "SYSTEM", sizeof(g_defaults.dirs[DEFAULT_DIR_SYSTEM])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_LOGS], user_path, "LOGS", sizeof(g_defaults.dirs[DEFAULT_DIR_LOGS])); /* cache dir */ fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_CACHE], user_path, "TEMP", sizeof(g_defaults.dirs[DEFAULT_DIR_CACHE])); /* history and main config */ strlcpy(g_defaults.dirs[DEFAULT_DIR_CONTENT_HISTORY], user_path, sizeof(g_defaults.dirs[DEFAULT_DIR_CONTENT_HISTORY])); fill_pathname_join(g_defaults.path.config, user_path, file_path_str(FILE_PATH_MAIN_CONFIG), sizeof(g_defaults.path.config)); }
void path_set_special(char **argv, unsigned num_content) { unsigned i; union string_list_elem_attr attr; global_t *global = global_get_ptr(); /* First content file is the significant one. */ path_set_basename(argv[0]); subsystem_fullpaths = string_list_new(); retro_assert(subsystem_fullpaths); attr.i = 0; for (i = 0; i < num_content; i++) string_list_append(subsystem_fullpaths, argv[i], attr); /* We defer SRAM path updates until we can resolve it. * It is more complicated for special content types. */ if (global) { if (!retroarch_override_setting_is_set(RARCH_OVERRIDE_SETTING_STATE_PATH, NULL)) fill_pathname_noext(global->name.savestate, path_main_basename, file_path_str(FILE_PATH_STATE_EXTENSION), sizeof(global->name.savestate)); if (path_is_directory(global->name.savestate)) { fill_pathname_dir(global->name.savestate, path_main_basename, file_path_str(FILE_PATH_STATE_EXTENSION), sizeof(global->name.savestate)); RARCH_LOG("%s \"%s\".\n", msg_hash_to_str(MSG_REDIRECTING_SAVESTATE_TO), global->name.savestate); } } }
static bool runloop_check_movie_init(void) { char msg[128] = {0}; char path[PATH_MAX_LENGTH] = {0}; settings_t *settings = config_get_ptr(); if (bsv_movie_ctl(BSV_MOVIE_CTL_IS_INITED, NULL)) return false; settings->rewind_granularity = 1; if (settings->state_slot > 0) snprintf(path, sizeof(path), "%s%d", bsv_movie_get_path(), settings->state_slot); else strlcpy(path, bsv_movie_get_path(), sizeof(path)); strlcat(path, file_path_str(FILE_PATH_BSV_EXTENSION), sizeof(path)); snprintf(msg, sizeof(msg), "%s \"%s\".", msg_hash_to_str(MSG_STARTING_MOVIE_RECORD_TO), path); bsv_movie_init_handle(path, RARCH_MOVIE_RECORD); if (!bsv_movie_ctl(BSV_MOVIE_CTL_IS_INITED, NULL)) return false; if (bsv_movie_ctl(BSV_MOVIE_CTL_IS_INITED, NULL)) { runloop_msg_queue_push(msg, 2, 180, true); RARCH_LOG("%s \"%s\".\n", msg_hash_to_str(MSG_STARTING_MOVIE_RECORD_TO), path); } else { runloop_msg_queue_push( msg_hash_to_str(MSG_FAILED_TO_START_MOVIE_RECORD), 2, 180, true); RARCH_ERR("%s\n", msg_hash_to_str(MSG_FAILED_TO_START_MOVIE_RECORD)); } return true; }
void ShaderParamsDialog::onShaderLoadPresetClicked() { QString path; QString filter; QByteArray pathArray; struct video_shader *menu_shader = NULL; struct video_shader *video_shader = NULL; const char *pathData = NULL; settings_t *settings = config_get_ptr(); enum rarch_shader_type type = RARCH_SHADER_NONE; bool is_preset = false; if (!settings) return; getShaders(&menu_shader, &video_shader); if (!menu_shader) return; filter = "Shader Preset ("; /* NOTE: Maybe we should have a way to get a list of all shader types instead of hard-coding this? */ if (video_shader_is_supported(RARCH_SHADER_CG) && video_shader_get_type_from_ext(file_path_str(FILE_PATH_CGP_EXTENSION), &is_preset) != RARCH_SHADER_NONE) filter += QLatin1Literal("*") + file_path_str(FILE_PATH_CGP_EXTENSION); if (video_shader_is_supported(RARCH_SHADER_GLSL) && video_shader_get_type_from_ext(file_path_str(FILE_PATH_GLSLP_EXTENSION), &is_preset) != RARCH_SHADER_NONE) filter += QLatin1Literal(" *") + file_path_str(FILE_PATH_GLSLP_EXTENSION); if (video_shader_is_supported(RARCH_SHADER_SLANG) && video_shader_get_type_from_ext(file_path_str(FILE_PATH_SLANGP_EXTENSION), &is_preset) != RARCH_SHADER_NONE) filter += QLatin1Literal(" *") + file_path_str(FILE_PATH_SLANGP_EXTENSION); filter += ")"; path = QFileDialog::getOpenFileName(this, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET), settings->paths.directory_video_shader, filter); if (path.isEmpty()) return; pathArray = path.toUtf8(); pathData = pathArray.constData(); type = video_shader_parse_type(pathData, RARCH_SHADER_NONE); menu_shader_manager_set_preset(menu_shader, type, pathData); }
static int action_bind_label_playlist_collection_entry( file_list_t *list, unsigned type, unsigned i, const char *label, const char *path, char *s, size_t len) { if (strstr(path, file_path_str(FILE_PATH_LPL_EXTENSION))) { char path_base[PATH_MAX_LENGTH]; path_base[0] = '\0'; fill_short_pathname_representation_noext(path_base, path, sizeof(path_base)); strlcpy(s, path_base, len); } return 0; }
static void frontend_wiiu_get_environment_settings(int *argc, char *argv[], void *args, void *params_data) { unsigned i; (void)args; fill_pathname_basedir(g_defaults.dirs[DEFAULT_DIR_PORT], elf_path_cst, sizeof(g_defaults.dirs[DEFAULT_DIR_PORT])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_CORE_ASSETS], g_defaults.dirs[DEFAULT_DIR_PORT], "downloads", sizeof(g_defaults.dirs[DEFAULT_DIR_CORE_ASSETS])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_ASSETS], g_defaults.dirs[DEFAULT_DIR_PORT], "media", sizeof(g_defaults.dirs[DEFAULT_DIR_ASSETS])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_CORE], g_defaults.dirs[DEFAULT_DIR_PORT], "cores", sizeof(g_defaults.dirs[DEFAULT_DIR_CORE])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_CORE_INFO], g_defaults.dirs[DEFAULT_DIR_CORE], "info", sizeof(g_defaults.dirs[DEFAULT_DIR_CORE_INFO])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_SAVESTATE], g_defaults.dirs[DEFAULT_DIR_CORE], "savestates", sizeof(g_defaults.dirs[DEFAULT_DIR_SAVESTATE])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_SRAM], g_defaults.dirs[DEFAULT_DIR_CORE], "savefiles", sizeof(g_defaults.dirs[DEFAULT_DIR_SRAM])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_SYSTEM], g_defaults.dirs[DEFAULT_DIR_CORE], "system", sizeof(g_defaults.dirs[DEFAULT_DIR_SYSTEM])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_PLAYLIST], g_defaults.dirs[DEFAULT_DIR_CORE], "playlists", sizeof(g_defaults.dirs[DEFAULT_DIR_PLAYLIST])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_MENU_CONFIG], g_defaults.dirs[DEFAULT_DIR_PORT], "config", sizeof(g_defaults.dirs[DEFAULT_DIR_MENU_CONFIG])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_REMAP], g_defaults.dirs[DEFAULT_DIR_PORT], "config/remaps", sizeof(g_defaults.dirs[DEFAULT_DIR_REMAP])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_VIDEO_FILTER], g_defaults.dirs[DEFAULT_DIR_PORT], "filters", sizeof(g_defaults.dirs[DEFAULT_DIR_VIDEO_FILTER])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_DATABASE], g_defaults.dirs[DEFAULT_DIR_PORT], "database/rdb", sizeof(g_defaults.dirs[DEFAULT_DIR_DATABASE])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_CURSOR], g_defaults.dirs[DEFAULT_DIR_PORT], "database/cursors", sizeof(g_defaults.dirs[DEFAULT_DIR_CURSOR])); fill_pathname_join(g_defaults.path.config, g_defaults.dirs[DEFAULT_DIR_PORT], file_path_str(FILE_PATH_MAIN_CONFIG), sizeof(g_defaults.path.config)); for (i = 0; i < DEFAULT_DIR_LAST; i++) { const char *dir_path = g_defaults.dirs[i]; if (!string_is_empty(dir_path)) path_mkdir(dir_path); } }
/* Fills content_img field of path_data using existing * content_label field (for internal use only) */ static void fill_content_img(menu_thumbnail_path_data_t *path_data) { char *scrub_char_pointer = NULL; /* Copy source label string */ strlcpy(path_data->content_img, path_data->content_label, sizeof(path_data->content_img)); /* Scrub characters that are not cross-platform and/or violate the * No-Intro filename standard: * http://datomatic.no-intro.org/stuff/The%20Official%20No-Intro%20Convention%20(20071030).zip * Replace these characters in the entry name with underscores */ while((scrub_char_pointer = strpbrk(path_data->content_img, "&*/:`\"<>?\\|"))) *scrub_char_pointer = '_'; /* Add PNG extension */ strlcat(path_data->content_img, file_path_str(FILE_PATH_PNG_EXTENSION), sizeof(path_data->content_img)); }
QVector<QHash<QString, QString> > MainWindow::getPlaylistDefaultCores() { settings_t *settings = config_get_ptr(); struct string_list *playlists = string_split(settings->arrays.playlist_names, ";"); struct string_list *cores = string_split(settings->arrays.playlist_cores, ";"); unsigned i = 0; QVector<QHash<QString, QString> > coreList; if (!playlists || !cores) { RARCH_WARN("[Qt]: Could not parse one of playlist_names or playlist_cores\n"); goto finish; } else if (playlists->size != cores->size) { RARCH_WARN("[Qt]: playlist_names array size differs from playlist_cores\n"); goto finish; } if (playlists->size == 0) goto finish; for (i = 0; i < playlists->size; i++) { const char *playlist = playlists->elems[i].data; const char *core = cores->elems[i].data; QHash<QString, QString> hash; hash["playlist_filename"] = playlist; hash["playlist_filename"].remove(file_path_str(FILE_PATH_LPL_EXTENSION)); hash["core_path"] = core; coreList.append(hash); } finish: if (playlists) string_list_free(playlists); if (cores) string_list_free(cores); return coreList; }
void input_config_parse_joy_axis(void *data, const char *prefix, const char *axis, struct retro_keybind *bind) { char str[256]; char tmp[64]; char key[64]; char key_label[64]; char *tmp_a = NULL; config_file_t *conf = (config_file_t*)data; str[0] = tmp[0] = key[0] = key_label[0] = '\0'; fill_pathname_join_delim(str, prefix, axis, '_', sizeof(str)); fill_pathname_join_delim(key, str, "axis", '_', sizeof(key)); fill_pathname_join_delim(key_label, str, "axis_label", '_', sizeof(key_label)); if (config_get_array(conf, key, tmp, sizeof(tmp))) { if (string_is_equal(tmp, file_path_str(FILE_PATH_NUL))) bind->joyaxis = AXIS_NONE; else if (strlen(tmp) >= 2 && (*tmp == '+' || *tmp == '-')) { int i_axis = strtol(tmp + 1, NULL, 0); if (*tmp == '+') bind->joyaxis = AXIS_POS(i_axis); else bind->joyaxis = AXIS_NEG(i_axis); } /* Ensure that D-pad emulation doesn't screw this over. */ bind->orig_joyaxis = bind->joyaxis; } if (config_get_string(conf, key_label, &tmp_a)) { strlcpy(bind->joyaxis_label, tmp_a, sizeof(bind->joyaxis_label)); free(tmp_a); } }
void cb_net_generic_subdir(retro_task_t *task, void *task_data, void *user_data, const char *err) { #ifdef HAVE_NETWORKING char subdir_path[PATH_MAX_LENGTH]; http_transfer_data_t *data = (http_transfer_data_t*)task_data; file_transfer_t *state = (file_transfer_t*)user_data; subdir_path[0] = '\0'; if (!data || err) goto finish; if (!string_is_empty(data->data)) memcpy(subdir_path, data->data, data->len * sizeof(char)); subdir_path[data->len] = '\0'; finish: if (!err && !strstr(subdir_path, file_path_str(FILE_PATH_INDEX_DIRS_URL))) { char parent_dir[PATH_MAX_LENGTH]; parent_dir[0] = '\0'; fill_pathname_parent_dir(parent_dir, state->path, sizeof(parent_dir)); /*generic_action_ok_displaylist_push(parent_dir, NULL, subdir_path, 0, 0, 0, ACTION_OK_DL_CORE_CONTENT_DIRS_SUBDIR_LIST);*/ } if (data) { if (data->data) free(data->data); free(data); } if (user_data) free(user_data); #endif }
static bool core_info_list_iterate( char *s, size_t len, const char *path_basedir, struct string_list *contents, size_t i) { size_t info_path_base_size = PATH_MAX_LENGTH * sizeof(char); char *info_path_base = NULL; char *substr = NULL; const char *current_path = contents ? contents->elems[i].data : NULL; (void)substr; if (!current_path) return false; info_path_base = (char*)malloc(info_path_base_size); info_path_base[0] = '\0'; fill_pathname_base_noext(info_path_base, current_path, info_path_base_size); #if defined(RARCH_MOBILE) || (defined(RARCH_CONSOLE) && !defined(PSP) && !defined(_3DS) && !defined(VITA) && !defined(PS2) && !defined(HW_WUP)) substr = strrchr(info_path_base, '_'); if (substr) *substr = '\0'; #endif strlcat(info_path_base, file_path_str(FILE_PATH_CORE_INFO_EXTENSION), info_path_base_size); fill_pathname_join(s, path_basedir, info_path_base, len); free(info_path_base); return true; }
static void frontend_wiiu_get_environment_settings(int *argc, char *argv[], void *args, void *params_data) { (void)args; DEBUG_LINE(); fill_pathname_basedir(g_defaults.dir.port, elf_path_cst, sizeof(g_defaults.dir.port)); DEBUG_LINE(); RARCH_LOG("port dir: [%s]\n", g_defaults.dir.port); fill_pathname_join(g_defaults.dir.core_assets, g_defaults.dir.port, "downloads", sizeof(g_defaults.dir.core_assets)); fill_pathname_join(g_defaults.dir.assets, g_defaults.dir.port, "media", sizeof(g_defaults.dir.assets)); fill_pathname_join(g_defaults.dir.core, g_defaults.dir.port, "cores", sizeof(g_defaults.dir.core)); fill_pathname_join(g_defaults.dir.core_info, g_defaults.dir.core, "info", sizeof(g_defaults.dir.core_info)); fill_pathname_join(g_defaults.dir.savestate, g_defaults.dir.core, "savestates", sizeof(g_defaults.dir.savestate)); fill_pathname_join(g_defaults.dir.sram, g_defaults.dir.core, "savefiles", sizeof(g_defaults.dir.sram)); fill_pathname_join(g_defaults.dir.system, g_defaults.dir.core, "system", sizeof(g_defaults.dir.system)); fill_pathname_join(g_defaults.dir.playlist, g_defaults.dir.core, "playlists", sizeof(g_defaults.dir.playlist)); fill_pathname_join(g_defaults.dir.menu_config, g_defaults.dir.port, "config", sizeof(g_defaults.dir.menu_config)); fill_pathname_join(g_defaults.dir.remap, g_defaults.dir.port, "config/remaps", sizeof(g_defaults.dir.remap)); fill_pathname_join(g_defaults.dir.video_filter, g_defaults.dir.port, "filters", sizeof(g_defaults.dir.remap)); fill_pathname_join(g_defaults.dir.database, g_defaults.dir.port, "database/rdb", sizeof(g_defaults.dir.database)); fill_pathname_join(g_defaults.dir.cursor, g_defaults.dir.port, "database/cursors", sizeof(g_defaults.dir.cursor)); fill_pathname_join(g_defaults.path.config, g_defaults.dir.port, file_path_str(FILE_PATH_MAIN_CONFIG), sizeof(g_defaults.path.config)); }
void input_config_parse_joy_button(void *data, const char *prefix, const char *btn, struct retro_keybind *bind) { char str[256]; char tmp[64]; char key[64]; char key_label[64]; char *tmp_a = NULL; config_file_t *conf = (config_file_t*)data; str[0] = tmp[0] = key[0] = key_label[0] = '\0'; fill_pathname_join_delim(str, prefix, btn, '_', sizeof(str)); fill_pathname_join_delim(key, str, "btn", '_', sizeof(key)); fill_pathname_join_delim(key_label, str, "btn_label", '_', sizeof(key_label)); if (config_get_array(conf, key, tmp, sizeof(tmp))) { btn = tmp; if (string_is_equal(btn, file_path_str(FILE_PATH_NUL))) bind->joykey = NO_BTN; else { if (*btn == 'h') parse_hat(bind, btn + 1); else bind->joykey = strtoull(tmp, NULL, 0); } } if (config_get_string(conf, key_label, &tmp_a)) { strlcpy(bind->joykey_label, tmp_a, sizeof(bind->joykey_label)); free(tmp_a); } }
static int task_database_iterate_playlist_lutro( db_handle_t *_db, database_state_handle_t *db_state, database_info_handle_t *db, const char *path) { char *db_playlist_path = (char*)malloc(PATH_MAX_LENGTH * sizeof(char)); playlist_t *playlist = NULL; db_playlist_path[0] = '\0'; if (!string_is_empty(_db->playlist_directory)) fill_pathname_join(db_playlist_path, _db->playlist_directory, file_path_str(FILE_PATH_LUTRO_PLAYLIST), PATH_MAX_LENGTH * sizeof(char)); playlist = playlist_init(db_playlist_path, COLLECTION_SIZE); free(db_playlist_path); if(!playlist_entry_exists(playlist, path, file_path_str(FILE_PATH_DETECT))) { char *game_title = (char*)malloc(PATH_MAX_LENGTH * sizeof(char)); game_title[0] = '\0'; fill_short_pathname_representation_noext(game_title, path, PATH_MAX_LENGTH * sizeof(char)); playlist_push(playlist, path, game_title, file_path_str(FILE_PATH_DETECT), file_path_str(FILE_PATH_DETECT), file_path_str(FILE_PATH_DETECT), file_path_str(FILE_PATH_LUTRO_PLAYLIST)); free(game_title); } playlist_write_file(playlist); playlist_free(playlist); return 0; }
void ozone_context_destroy_horizontal_list(ozone_handle_t *ozone) { unsigned i; size_t list_size = ozone_list_get_size(ozone, MENU_LIST_HORIZONTAL); for (i = 0; i < list_size; i++) { const char *path = NULL; ozone_node_t *node = (ozone_node_t*)file_list_get_userdata_at_offset(ozone->horizontal_list, i); if (!node) continue; file_list_get_at_offset(ozone->horizontal_list, i, &path, NULL, NULL, NULL); if (!path || !strstr(path, file_path_str(FILE_PATH_LPL_EXTENSION))) continue; video_driver_texture_unload(&node->icon); video_driver_texture_unload(&node->content_icon); } }
static int task_database_iterate_playlist_lutro( database_state_handle_t *db_state, database_info_handle_t *db, const char *path) { char db_playlist_path[PATH_MAX_LENGTH]; playlist_t *playlist = NULL; settings_t *settings = config_get_ptr(); db_playlist_path[0] = '\0'; fill_pathname_join(db_playlist_path, settings->directory.playlist, file_path_str(FILE_PATH_LUTRO_PLAYLIST), sizeof(db_playlist_path)); playlist = playlist_init(db_playlist_path, COLLECTION_SIZE); if(!playlist_entry_exists(playlist, path, file_path_str(FILE_PATH_DETECT))) { char game_title[PATH_MAX_LENGTH]; game_title[0] = '\0'; fill_short_pathname_representation_noext(game_title, path, sizeof(game_title)); playlist_push(playlist, path, game_title, file_path_str(FILE_PATH_DETECT), file_path_str(FILE_PATH_DETECT), file_path_str(FILE_PATH_DETECT), file_path_str(FILE_PATH_LUTRO_PLAYLIST)); } playlist_write_file(playlist); playlist_free(playlist); return 0; }