static void salamander_init(void) { CellPadData pad_data; cellPadInit(7); cellPadGetData(0, &pad_data); if(pad_data.button[CELL_PAD_BTN_OFFSET_DIGITAL2] & CELL_PAD_CTRL_TRIANGLE) { //override path, boot first executable in cores directory RARCH_LOG("Fallback - Will boot first executable in RetroArch cores/ directory.\n"); find_and_set_first_file(); } else { //normal executable loading path char tmp_str[PATH_MAX]; bool config_file_exists = false; if (path_file_exists(config_path)) config_file_exists = true; //try to find CORE executable char core_executable[1024]; fill_pathname_join(core_executable, default_paths.core_dir, "CORE.SELF", sizeof(core_executable)); if(path_file_exists(core_executable)) { //Start CORE executable strlcpy(libretro_path, core_executable, sizeof(libretro_path)); RARCH_LOG("Start [%s].\n", libretro_path); } else { if (config_file_exists) { config_file_t * conf = config_file_new(config_path); config_get_array(conf, "libretro_path", tmp_str, sizeof(tmp_str)); config_file_free(conf); strlcpy(libretro_path, tmp_str, sizeof(libretro_path)); } if (!config_file_exists || !strcmp(libretro_path, "")) find_and_set_first_file(); else RARCH_LOG("Start [%s] found in retroarch.cfg.\n", libretro_path); if (!config_file_exists) { config_file_t *new_conf = config_file_new(NULL); config_set_string(new_conf, "libretro_path", libretro_path); config_file_write(new_conf, config_path); config_file_free(new_conf); } } } cellPadEnd(); }
int main(int argc, char *argv[]) { parse_input(argc, argv); config_file_t *conf = config_file_new(g_in_path); if (!conf) { fprintf(stderr, "Couldn't open config file ...\n"); return 1; } const char *index_list[] = { "input_player1_joypad_index", "input_player2_joypad_index", "input_player3_joypad_index", "input_player4_joypad_index", "input_player5_joypad_index", "input_player6_joypad_index", "input_player7_joypad_index", "input_player8_joypad_index", }; config_set_int(conf, index_list[g_player - 1], g_joypad); get_binds(conf, g_player - 1, g_joypad); config_file_write(conf, g_out_path); config_file_free(conf); if (g_in_path) free(g_in_path); if (g_out_path) free(g_out_path); return 0; }
int main(int argc, char *argv[]) { config_file_t *conf; config_file_t *auto_conf = NULL; const char *index_list[] = { "input_player1_joypad_index", "input_player2_joypad_index", "input_player3_joypad_index", "input_player4_joypad_index", "input_player5_joypad_index", "input_player6_joypad_index", "input_player7_joypad_index", "input_player8_joypad_index", }; parse_input(argc, argv); conf = config_file_new(g_in_path); if (!conf) { fprintf(stderr, "Couldn't open config file ...\n"); return 1; } config_set_int(conf, index_list[g_player - 1], g_joypad); if (g_auto_path) auto_conf = config_file_new(NULL); get_binds(conf, auto_conf, g_player - 1, g_joypad); config_file_write(conf, g_out_path); config_file_free(conf); if (auto_conf) { fprintf(stderr, "Writing autoconfig profile to: %s.\n", g_auto_path); config_file_write(auto_conf, g_auto_path); config_file_free(auto_conf); } free(g_in_path); free(g_out_path); free(g_auto_path); return 0; }
void core_option_flush(core_option_manager_t *opt) { for (size_t i = 0; i < opt->size; i++) { struct core_option *option = &opt->opts[i]; config_set_string(opt->conf, option->key, core_option_get_val(opt, i)); } config_file_write(opt->conf, opt->conf_path); }
/** * cheat_manager_save: * @path : Path to cheats file (relative path). * * Saves cheats to file on disk. * * Returns: true (1) if successful, otherwise false (0). **/ bool cheat_manager_save(const char *path) { bool ret; unsigned i; config_file_t *conf = NULL; char buf[PATH_MAX_LENGTH] = {0}; char cheats_file[PATH_MAX_LENGTH] = {0}; settings_t *settings = config_get_ptr(); cheat_manager_t *handle = cheat_manager_state; fill_pathname_join(buf, settings->path.cheat_database, path, sizeof(buf)); fill_pathname_noext(cheats_file, buf, ".cht", sizeof(cheats_file)); conf = config_file_new(cheats_file); if (!conf) conf = config_file_new(NULL); if (!conf) return false; if (!handle) { config_file_free(conf); return false; } config_set_int(conf, "cheats", handle->size); for (i = 0; i < handle->size; i++) { char key[64] = {0}; char desc_key[256] = {0}; char code_key[256] = {0}; char enable_key[256] = {0}; snprintf(key, sizeof(key), "cheat%u", i); snprintf(desc_key, sizeof(desc_key), "cheat%u_desc", i); snprintf(code_key, sizeof(code_key), "cheat%u_code", i); snprintf(enable_key, sizeof(enable_key), "cheat%u_enable", i); if (handle->cheats[i].desc) config_set_string(conf, desc_key, handle->cheats[i].desc); else config_set_string(conf, desc_key, handle->cheats[i].code); config_set_string(conf, code_key, handle->cheats[i].code); config_set_bool(conf, enable_key, handle->cheats[i].state); } ret = config_file_write(conf, cheats_file); config_file_free(conf); return ret; }
static void salamander_init(char *s, size_t len) { /* normal executable loading path */ bool config_file_exists = false; if (path_file_exists(g_defaults.path.config)) config_file_exists = true; if (config_file_exists) { char tmp_str[PATH_MAX_LENGTH]; config_file_t * conf = (config_file_t*)config_file_new(g_defaults.path.config); if (conf) { config_get_array(conf, "libretro_path", tmp_str, sizeof(tmp_str)); config_file_free(conf); if (strcmp(tmp_str, "builtin") != 0) strlcpy(s, tmp_str, len); } #ifdef GEKKO /* stupid libfat bug or something; sometimes it says * the file is there when it doesn't. */ else { config_file_exists = false; } #endif } if (!config_file_exists || !strcmp(s, "")) { char executable_name[PATH_MAX_LENGTH]; frontend_driver_get_core_extension( executable_name, sizeof(executable_name)); find_and_set_first_file(s, len, executable_name); } else RARCH_LOG("Start [%s] found in retroarch.cfg.\n", s); if (!config_file_exists) { config_file_t *conf = (config_file_t*)config_file_new(NULL); if (conf) { config_set_string(conf, "libretro_path", s); config_file_write(conf, g_defaults.path.config); config_file_free(conf); } } }
static void salamander_init_settings(void) { char tmp_str[512] = {0}; bool config_file_exists; if(!path_file_exists(default_paths.config_path)) { FILE * f; config_file_exists = false; RARCH_ERR("Config file \"%s\" doesn't exist. Creating...\n", default_paths.config_path); MAKE_DIR(default_paths.port_dir); f = fopen(default_paths.config_path, "w"); fclose(f); } else config_file_exists = true; //try to find CORE executable char core_executable[1024]; snprintf(core_executable, sizeof(core_executable), "%s/CORE.dol", default_paths.core_dir); if(path_file_exists(core_executable)) { //Start CORE executable snprintf(default_paths.libretro_path, sizeof(default_paths.libretro_path), core_executable); RARCH_LOG("Start [%s].\n", default_paths.libretro_path); } else { if(config_file_exists) { config_file_t * conf = config_file_new(default_paths.config_path); config_get_array(conf, "libretro_path", tmp_str, sizeof(tmp_str)); config_file_free(conf); snprintf(default_paths.libretro_path, sizeof(default_paths.libretro_path), tmp_str); } if(!config_file_exists || !strcmp(default_paths.libretro_path, "")) find_and_set_first_file(); else { RARCH_LOG("Start [%s] found in retroarch.cfg.\n", default_paths.libretro_path); } if (!config_file_exists) { config_file_t *new_conf = config_file_new(NULL); config_set_string(new_conf, "libretro_path", default_paths.libretro_path); config_file_write(new_conf, default_paths.config_path); config_file_free(new_conf); } } }
/** * core_option_flush: * @opt : options manager handle * * Writes core option key-pair values to file. * * Returns: true (1) if core option values could be * successfully saved to disk, otherwise false (0). **/ bool core_option_flush(core_option_manager_t *opt) { size_t i; for (i = 0; i < opt->size; i++) { struct core_option *option = (struct core_option*)&opt->opts[i]; if (option) config_set_string(opt->conf, option->key, core_option_get_val(opt, i)); } return config_file_write(opt->conf, opt->conf_path); }
static void salamander_init(void) { char tmp_str[512] = {0}; bool config_file_exists; if (path_file_exists(config_path)) config_file_exists = true; //try to find CORE executable char core_executable[1024]; fill_pathname_join(core_executable, default_paths.core_dir, "CORE.dol", sizeof(core_executable)); if(path_file_exists(core_executable)) { //Start CORE executable strlcpy(libretro_path, core_executable, sizeof(libretro_path)); RARCH_LOG("Start [%s].\n", libretro_path); } else { if(config_file_exists) { config_file_t * conf = config_file_new(config_path); if (!conf) // stupid libfat bug or something; somtimes it says the file is there when it doesn't config_file_exists = false; else { config_get_array(conf, "libretro_path", tmp_str, sizeof(tmp_str)); config_file_free(conf); strlcpy(libretro_path, tmp_str, sizeof(libretro_path)); } } if(!config_file_exists || !strcmp(libretro_path, "")) find_and_set_first_file(); else { RARCH_LOG("Start [%s] found in retroarch.cfg.\n", libretro_path); } if (!config_file_exists) { config_file_t *new_conf = config_file_new(NULL); config_set_string(new_conf, "libretro_path", libretro_path); config_file_write(new_conf, config_path); config_file_free(new_conf); } } }
/** * core_option_manager_flush_game_specific: * @opt : options manager handle * @path : path for the core options file * * Writes core option key-pair values to a custom file. * * Returns: true (1) if core option values could be * successfully saved to disk, otherwise false (0). **/ bool core_option_manager_flush_game_specific( core_option_manager_t *opt, const char* path) { size_t i; for (i = 0; i < opt->size; i++) { struct core_option *option = (struct core_option*)&opt->opts[i]; if (option) config_set_string(opt->conf, option->key, core_option_manager_get_val(opt, i)); } return config_file_write(opt->conf, path); }
/** * core_option_manager_flush: * @opt : options manager handle * * Writes core option key-pair values to file. * * Returns: true (1) if core option values could be * successfully saved to disk, otherwise false (0). **/ bool core_option_manager_flush(core_option_manager_t *opt) { size_t i; for (i = 0; i < opt->size; i++) { struct core_option *option = (struct core_option*)&opt->opts[i]; if (option) config_set_string(opt->conf, option->key, core_option_manager_get_val(opt, i)); } RARCH_LOG("Saved core options file to \"%s\"\n", opt->conf_path); return config_file_write(opt->conf, opt->conf_path); }
static void salamander_init(char *libretro_path, size_t sizeof_libretro_path) { //normal executable loading path bool config_file_exists = false; if (path_file_exists(default_paths.config_path)) config_file_exists = true; if (config_file_exists) { char tmp_str[PATH_MAX]; config_file_t * conf = (config_file_t*)config_file_new(default_paths.config_path); if (conf) { config_get_array(conf, "libretro_path", tmp_str, sizeof(tmp_str)); config_file_free(conf); strlcpy(libretro_path, tmp_str, sizeof_libretro_path); } #ifdef GEKKO else // stupid libfat bug or something; somtimes it says the file is there when it doesn't config_file_exists = false; #endif } if (!config_file_exists || !strcmp(libretro_path, "")) find_and_set_first_file(libretro_path, sizeof_libretro_path, EXT_EXECUTABLES); else RARCH_LOG("Start [%s] found in retroarch.cfg.\n", libretro_path); if (!config_file_exists) { config_file_t *conf = (config_file_t*)config_file_new(NULL); if (conf) { config_set_string(conf, "libretro_path", libretro_path); config_file_write(conf, default_paths.config_path); config_file_free(conf); } } }
static void salamander_init(char *s, size_t len) { /* normal executable loading path */ bool config_file_exists = false; if (path_file_exists(g_defaults.path.config)) config_file_exists = true; if (config_file_exists) { char tmp_str[PATH_MAX_LENGTH]; config_file_t * conf = (config_file_t*)config_file_new(g_defaults.path.config); if (conf) { config_get_array(conf, "libretro_path", tmp_str, sizeof(tmp_str)); config_file_free(conf); strlcpy(s, tmp_str, len); } #ifdef GEKKO else /* stupid libfat bug or something; sometimes it says the file is there when it doesn't */ config_file_exists = false; #endif } if (!config_file_exists || !strcmp(s, "")) find_and_set_first_file(s, len, EXT_EXECUTABLES); else RARCH_LOG("Start [%s] found in retroarch.cfg.\n", s); if (!config_file_exists) { config_file_t *conf = (config_file_t*)config_file_new(NULL); if (conf) { config_set_string(conf, "libretro_path", s); config_file_write(conf, g_defaults.path.config); config_file_free(conf); } } }
static void cheat_manager_save_config(cheat_manager_t *handle, const char *path, const char *sha256) { if (!(*path)) return; config_file_t *conf = config_file_new(path); if (!conf) conf = config_file_new(NULL); if (!conf) { RARCH_ERR("Cannot save XML cheat settings.\n"); return; } unsigned i; char conf_str[512] = {0}; char tmp[32] = {0}; for (i = 0; i < handle->size; i++) { if (handle->cheats[i].state) { snprintf(tmp, sizeof(tmp), "%u;", i); strlcat(conf_str, tmp, sizeof(conf_str)); } } if (*conf_str) conf_str[strlen(conf_str) - 1] = '\0'; // Remove the trailing ';' config_set_string(conf, sha256, conf_str); if (!config_file_write(conf, path)) RARCH_ERR("Failed to write XML cheat settings to \"%s\". Check permissions.\n", path); config_file_free(conf); }
void menu_shader_manager_save_preset( const char *basename, bool apply) { char buffer[PATH_MAX], config_directory[PATH_MAX], cgp_path[PATH_MAX]; unsigned d, type = RARCH_SHADER_NONE; config_file_t *conf = NULL; bool ret = false; if (!driver.menu) { RARCH_ERR("Cannot save shader preset, menu handle is not initialized.\n"); return; } type = menu_shader_manager_get_type(driver.menu->shader); if (type == RARCH_SHADER_NONE) return; *config_directory = '\0'; if (basename) { strlcpy(buffer, basename, sizeof(buffer)); /* Append extension automatically as appropriate. */ if (!strstr(basename, ".cgp") && !strstr(basename, ".glslp")) { if (type == RARCH_SHADER_GLSL) strlcat(buffer, ".glslp", sizeof(buffer)); else if (type == RARCH_SHADER_CG) strlcat(buffer, ".cgp", sizeof(buffer)); } } else { const char *conf_path = (type == RARCH_SHADER_GLSL) ? driver.menu->default_glslp : driver.menu->default_cgp; strlcpy(buffer, conf_path, sizeof(buffer)); } if (*g_extern.config_path) fill_pathname_basedir(config_directory, g_extern.config_path, sizeof(config_directory)); const char *dirs[] = { g_settings.video.shader_dir, g_settings.menu_config_directory, config_directory, }; if (!(conf = (config_file_t*)config_file_new(NULL))) return; gfx_shader_write_conf_cgp(conf, driver.menu->shader); for (d = 0; d < ARRAY_SIZE(dirs); d++) { if (!*dirs[d]) continue; fill_pathname_join(cgp_path, dirs[d], buffer, sizeof(cgp_path)); if (config_file_write(conf, cgp_path)) { RARCH_LOG("Saved shader preset to %s.\n", cgp_path); if (apply) menu_shader_manager_set_preset(NULL, type, cgp_path); ret = true; break; } else RARCH_LOG("Failed writing shader preset to %s.\n", cgp_path); } config_file_free(conf); if (!ret) RARCH_ERR("Failed to save shader preset. Make sure config directory and/or shader dir are writable.\n"); }
/** * menu_shader_manager_save_preset: * @basename : basename of preset * @apply : immediately set preset after saving * * Save a shader preset to disk. **/ void menu_shader_manager_save_preset( const char *basename, bool apply) { #ifdef HAVE_SHADER_MANAGER char buffer[PATH_MAX_LENGTH], config_directory[PATH_MAX_LENGTH], preset_path[PATH_MAX_LENGTH]; unsigned d, type = RARCH_SHADER_NONE; const char *dirs[3] = {0}; config_file_t *conf = NULL; bool ret = false; global_t *global = global_get_ptr(); settings_t *settings = config_get_ptr(); menu_handle_t *menu = menu_driver_get_ptr(); if (!menu) { RARCH_ERR("Cannot save shader preset, menu handle is not initialized.\n"); return; } type = menu_shader_manager_get_type(menu->shader); if (type == RARCH_SHADER_NONE) return; *config_directory = '\0'; if (basename) { strlcpy(buffer, basename, sizeof(buffer)); /* Append extension automatically as appropriate. */ if (!strstr(basename, ".cgp") && !strstr(basename, ".glslp")) { switch (type) { case RARCH_SHADER_GLSL: strlcat(buffer, ".glslp", sizeof(buffer)); break; case RARCH_SHADER_CG: strlcat(buffer, ".cgp", sizeof(buffer)); break; } } } else { const char *conf_path = (type == RARCH_SHADER_GLSL) ? menu->default_glslp : menu->default_cgp; strlcpy(buffer, conf_path, sizeof(buffer)); } if (*global->path.config) fill_pathname_basedir(config_directory, global->path.config, sizeof(config_directory)); dirs[0] = settings->video.shader_dir; dirs[1] = settings->menu_config_directory; dirs[2] = config_directory; if (!(conf = (config_file_t*)config_file_new(NULL))) return; video_shader_write_conf_cgp(conf, menu->shader); for (d = 0; d < ARRAY_SIZE(dirs); d++) { if (!*dirs[d]) continue; fill_pathname_join(preset_path, dirs[d], buffer, sizeof(preset_path)); if (config_file_write(conf, preset_path)) { RARCH_LOG("Saved shader preset to %s.\n", preset_path); if (apply) menu_shader_manager_set_preset(NULL, type, preset_path); ret = true; break; } else RARCH_LOG("Failed writing shader preset to %s.\n", preset_path); } config_file_free(conf); if (!ret) RARCH_ERR("Failed to save shader preset. Make sure config directory and/or shader dir are writable.\n"); #endif }
int main (int argc, char *argv[]) { GtkWidget *main_window; GOptionContext *context; GError *option_error; gchar *config_file_name, *dir; gboolean show_version = FALSE; GOptionEntry options[] = { { "version", 'v', 0, G_OPTION_ARG_NONE, &show_version, _("Show version information"), NULL }, {NULL} }; #ifdef WITH_HILDON HildonProgram *hildon_program; #endif #ifdef ENABLE_NLS bindtextdomain (PACKAGE, PACKAGE_LOCALE_DIR); bind_textdomain_codeset (PACKAGE, "UTF-8"); textdomain (PACKAGE); gtk_set_locale(); #endif /* Parse command line options */ context = g_option_context_new (NULL); g_option_context_set_summary(context, _("Carry out simple and scientific calculations")); #ifdef ENABLE_NLS g_option_context_add_main_entries (context, options, GETTEXT_PACKAGE); #else g_option_context_add_main_entries (context, options, NULL); #endif g_option_context_add_group (context, gtk_get_option_group (TRUE)); if (!g_option_context_parse (context, &argc, &argv, &option_error)) { if (option_error) g_print ("%s\n", option_error->message); return EXIT_FAILURE; } g_option_context_free (context); if(show_version == TRUE) { g_print(_("%s v%s, (c) 2002-2010 Simon Floery\n"), PACKAGE, VERSION); return EXIT_SUCCESS; } gtk_init (&argc, &argv); /* at first, get config file */ dir = g_build_filename (g_get_user_config_dir (), PACKAGE, NULL); g_mkdir_with_parents (dir, S_IRUSR | S_IWUSR | S_IXUSR); config_file_name = g_build_filename (dir, CONFIG_FILE_NAME, NULL); g_free(dir); prefs = config_file_read (config_file_name); constant = config_file_get_constants(); user_function = config_file_get_user_functions(); g_free (config_file_name); current_status.notation = prefs.def_notation; #ifdef WITH_HILDON gtkbuilder_register_widget (HILDON_TYPE_WINDOW, gtkbuilder_hildon_window_new, gtkbuilder_standard_build_children, NULL); hildon_program = HILDON_PROGRAM(hildon_program_get_instance()); #endif /* at first get the main frame */ /* sth like ui_launch_up_ui for splitting into first time wizard? */ main_window = ui_main_window_create(); #ifdef WITH_HILDON hildon_program_add_window(hildon_program, HILDON_WINDOW(main_window)); g_set_application_name(PACKAGE_NAME); create_hildon_menu(HILDON_WINDOW(main_window)); #endif /* set the window title */ #ifndef WITH_DEFCALC gtk_window_set_title ((GtkWindow *)main_window, PACKAGE_NAME); #else gtk_window_set_title ((GtkWindow *)main_window, "Calculator"); #endif /* set the window's icon */ #ifndef WITH_DEFCALC gtk_window_set_default_icon_name (PACKAGE); #else gtk_window_set_default_icon_name ("utilities-calculator"); #endif /* usually, only Shift, CTRL and ALT modifiers are paid attention to by * accelerator code. add MOD2 (NUMLOCK allover the world?) to the list. * We have to do this for a working keypad. */ gtk_accelerator_set_default_mod_mask (gtk_accelerator_get_default_mod_mask () | GDK_MOD2_MASK); /* prepare calc_basic */ main_alg = alg_init (0); rpn_init (prefs.stack_size, 0); /* apply changes */ apply_preferences (prefs); memory.data = NULL; memory.len = 0; /* see function key_snooper for details */ gtk_key_snooper_install (key_snooper, NULL); gtk_window_resize ((GtkWindow *)main_window, 1, 1); /* gtk_widget_show main window as late as possible */ gtk_widget_show (main_window); gtk_main (); /* save changes to file */ dir = g_build_filename (g_get_user_config_dir (), PACKAGE, NULL); g_mkdir_with_parents (dir, S_IRUSR | S_IWUSR | S_IXUSR); config_file_name = g_build_filename (dir, CONFIG_FILE_NAME, NULL); g_free(dir); config_file_write (config_file_name, prefs, constant, user_function); g_free (config_file_name); return EXIT_SUCCESS; }
static config_file_t *open_default_config_file(void) { config_file_t *conf = NULL; #if defined(_WIN32) && !defined(_XBOX) char conf_path[PATH_MAX]; char app_path[PATH_MAX]; fill_pathname_application_path(app_path, sizeof(app_path)); fill_pathname_resolve_relative(conf_path, app_path, "retroarch.cfg", sizeof(conf_path)); conf = config_file_new(conf_path); if (!conf) { const char *appdata = getenv("APPDATA"); if (appdata) { fill_pathname_join(conf_path, appdata, "retroarch.cfg", sizeof(conf_path)); conf = config_file_new(conf_path); } } // Try to create a new config file. if (!conf) { conf = config_file_new(NULL); bool saved = false; if (conf) // Since this is a clean config file, we can safely use config_save_on_exit. { fill_pathname_resolve_relative(conf_path, app_path, "retroarch.cfg", sizeof(conf_path)); config_set_bool(conf, "config_save_on_exit", true); saved = config_file_write(conf, conf_path); } if (saved) RARCH_WARN("Created new config file in: \"%s\".\n", conf_path); // WARN here to make sure user has a good chance of seeing it. else { RARCH_ERR("Failed to create new config file in: \"%s\".\n", conf_path); config_file_free(conf); conf = NULL; } } if (conf) strlcpy(g_extern.config_path, conf_path, sizeof(g_extern.config_path)); #elif !defined(__CELLOS_LV2__) && !defined(_XBOX) char conf_path[PATH_MAX]; const char *xdg = getenv("XDG_CONFIG_HOME"); const char *home = getenv("HOME"); // XDG_CONFIG_HOME falls back to $HOME/.config. if (xdg) fill_pathname_join(conf_path, xdg, "retroarch/retroarch.cfg", sizeof(conf_path)); else if (home) fill_pathname_join(conf_path, home, ".config/retroarch/retroarch.cfg", sizeof(conf_path)); if (xdg || home) { RARCH_LOG("Looking for config in: \"%s\".\n", conf_path); conf = config_file_new(conf_path); } // Fallback to $HOME/.retroarch.cfg. if (!conf && home) { fill_pathname_join(conf_path, home, ".retroarch.cfg", sizeof(conf_path)); RARCH_LOG("Looking for config in: \"%s\".\n", conf_path); conf = config_file_new(conf_path); } // Try to create a new config file. if (!conf && (home || xdg)) { // XDG_CONFIG_HOME falls back to $HOME/.config. if (xdg) fill_pathname_join(conf_path, xdg, "retroarch/retroarch.cfg", sizeof(conf_path)); else if (home) fill_pathname_join(conf_path, home, ".config/retroarch/retroarch.cfg", sizeof(conf_path)); char basedir[PATH_MAX]; fill_pathname_basedir(basedir, conf_path, sizeof(basedir)); if (path_mkdir(basedir)) { #ifndef GLOBAL_CONFIG_DIR #define GLOBAL_CONFIG_DIR "/etc" #endif char skeleton_conf[PATH_MAX]; fill_pathname_join(skeleton_conf, GLOBAL_CONFIG_DIR, "retroarch.cfg", sizeof(skeleton_conf)); conf = config_file_new(skeleton_conf); if (conf) RARCH_WARN("Using skeleton config \"%s\" as base for a new config file.\n", skeleton_conf); else conf = config_file_new(NULL); bool saved = false; if (conf) { config_set_bool(conf, "config_save_on_exit", true); // Since this is a clean config file, we can safely use config_save_on_exit. saved = config_file_write(conf, conf_path); } if (saved) RARCH_WARN("Created new config file in: \"%s\".\n", conf_path); // WARN here to make sure user has a good chance of seeing it. else { RARCH_ERR("Failed to create new config file in: \"%s\".\n", conf_path); config_file_free(conf); conf = NULL; } } } if (conf) strlcpy(g_extern.config_path, conf_path, sizeof(g_extern.config_path)); #endif return conf; }
static void salamander_init(void) { XINPUT_STATE state; (void)state; //WIP - no Xbox 1 controller input yet #ifdef _XBOX360 XInputGetState(0, &state); if(state.Gamepad.wButtons & XINPUT_GAMEPAD_Y) { //override path, boot first executable in cores directory RARCH_LOG("Fallback - Will boot first executable in RetroArch cores directory.\n"); find_and_set_first_file(); } else #endif { //normal executable loading path char tmp_str[PATH_MAX]; bool config_file_exists = false; if(path_file_exists(config_path)) config_file_exists = true; //try to find CORE executable char core_executable[1024]; #if defined(_XBOX360) strlcpy(core_executable, "game:\\CORE.xex", sizeof(core_executable)); #elif defined(_XBOX1) fill_pathname_join(core_executable, "D:", "CORE.xbe", sizeof(core_executable)); #endif if(path_file_exists(core_executable)) { //Start CORE executable strlcpy(libretro_path, core_executable, sizeof(libretro_path)); RARCH_LOG("Start [%s].\n", libretro_path); } else { if(config_file_exists) { config_file_t * conf = config_file_new(config_path); config_get_array(conf, "libretro_path", tmp_str, sizeof(tmp_str)); strlcpy(libretro_path, tmp_str, sizeof(libretro_path)); } if(!config_file_exists || !strcmp(libretro_path, "")) { find_and_set_first_file(); } else { RARCH_LOG("Start [%s] found in retroarch.cfg.\n", libretro_path); } if (!config_file_exists) { config_file_t *new_conf = config_file_new(NULL); config_set_string(new_conf, "libretro_path", libretro_path); config_file_write(new_conf, config_path); config_file_free(new_conf); } } } }
void rarch_config_save(const char * conf_name) { if(!path_file_exists(conf_name)) rarch_config_create_default(conf_name); else { config_file_t * conf = config_file_new(conf_name); if(conf == NULL) conf = config_file_new(NULL); // g_settings config_set_string(conf, "libretro_path", g_settings.libretro); #ifdef HAVE_XML config_set_string(conf, "cheat_database_path", g_settings.cheat_database); #endif config_set_bool(conf, "rewind_enable", g_settings.rewind_enable); config_set_string(conf, "video_cg_shader", g_settings.video.cg_shader_path); config_set_float(conf, "video_aspect_ratio", g_settings.video.aspect_ratio); #ifdef HAVE_FBO config_set_float(conf, "video_fbo_scale_x", g_settings.video.fbo_scale_x); config_set_float(conf, "video_fbo_scale_y", g_settings.video.fbo_scale_y); config_set_string(conf, "video_second_pass_shader", g_settings.video.second_pass_shader); config_set_bool(conf, "video_render_to_texture", g_settings.video.render_to_texture); config_set_bool(conf, "video_second_pass_smooth", g_settings.video.second_pass_smooth); #endif config_set_bool(conf, "video_smooth", g_settings.video.smooth); config_set_bool(conf, "video_vsync", g_settings.video.vsync); config_set_string(conf, "audio_device", g_settings.audio.device); for (unsigned i = 0; i < 7; i++) { char cfg[64]; snprintf(cfg, sizeof(cfg), "input_dpad_emulation_p%u", i + 1); config_set_int(conf, cfg, g_settings.input.dpad_emulation[i]); } #ifdef RARCH_CONSOLE config_set_bool(conf, "fbo_enabled", g_console.fbo_enabled); #ifdef __CELLOS_LV2__ config_set_bool(conf, "custom_bgm_enable", g_console.custom_bgm_enable); #endif config_set_bool(conf, "overscan_enable", g_console.overscan_enable); config_set_bool(conf, "screenshots_enable", g_console.screenshots_enable); #ifdef _XBOX config_set_bool(conf, "gamma_correction_enable", g_console.gamma_correction_enable); config_set_int(conf, "color_format", g_console.color_format); #endif config_set_bool(conf, "throttle_enable", g_console.throttle_enable); config_set_bool(conf, "triple_buffering_enable", g_console.triple_buffering_enable); config_set_bool(conf, "info_msg_enable", g_console.info_msg_enable); config_set_int(conf, "sound_mode", g_console.sound_mode); config_set_int(conf, "aspect_ratio_index", g_console.aspect_ratio_index); config_set_int(conf, "current_resolution_id", g_console.current_resolution_id); config_set_int(conf, "custom_viewport_width", g_console.viewports.custom_vp.width); config_set_int(conf, "custom_viewport_height", g_console.viewports.custom_vp.height); config_set_int(conf, "custom_viewport_x", g_console.viewports.custom_vp.x); config_set_int(conf, "custom_viewport_y", g_console.viewports.custom_vp.y); config_set_int(conf, "screen_orientation", g_console.screen_orientation); config_set_string(conf, "default_rom_startup_dir", g_console.default_rom_startup_dir); config_set_float(conf, "menu_font_size", g_console.menu_font_size); config_set_float(conf, "overscan_amount", g_console.overscan_amount); #endif // g_extern config_set_int(conf, "state_slot", g_extern.state_slot); config_set_int(conf, "audio_mute", g_extern.audio_data.mute); if (!config_file_write(conf, conf_name)) RARCH_ERR("Failed to write config file to \"%s\". Check permissions.\n", conf_name); free(conf); } }
/** * input_remapping_save_file: * @path : Path to remapping file (relative path). * * Saves remapping values to file. * * Returns: true (1) if successful, otherwise false (0). **/ bool input_remapping_save_file(const char *path) { bool ret; unsigned i, j, k; size_t path_size = PATH_MAX_LENGTH * sizeof(char); char *buf = (char*)malloc(PATH_MAX_LENGTH * sizeof(char)); char *remap_file = (char*)malloc(PATH_MAX_LENGTH * sizeof(char)); config_file_t *conf = NULL; unsigned max_users = *(input_driver_get_uint(INPUT_ACTION_MAX_USERS)); settings_t *settings = config_get_ptr(); buf[0] = remap_file[0] = '\0'; fill_pathname_join(buf, settings->paths.directory_input_remapping, path, path_size); fill_pathname_noext(remap_file, buf, ".rmp", path_size); free(buf); conf = config_file_new(remap_file); if (!conf) { conf = config_file_new(NULL); if (!conf) { free(remap_file); return false; } } for (i = 0; i < max_users; i++) { char s1[64], s2[64], s3[64]; char btn_ident[RARCH_FIRST_CUSTOM_BIND][128] = {{0}}; char key_ident[RARCH_FIRST_CUSTOM_BIND][128] = {{0}}; char stk_ident[8][128] = {{0}}; char key_strings[RARCH_FIRST_CUSTOM_BIND + 8][128] = { "b", "y", "select", "start", "up", "down", "left", "right", "a", "x", "l", "r", "l2", "r2", "l3", "r3", "l_x+", "l_x-", "l_y+", "l_y-", "r_x+", "r_x-", "r_y+", "r_y-" }; s1[0] = '\0'; s2[0] = '\0'; snprintf(s1, sizeof(s1), "input_player%u_btn", i + 1); snprintf(s2, sizeof(s2), "input_player%u_key", i + 1); snprintf(s3, sizeof(s1), "input_player%u_stk", i + 1); for (j = 0; j < RARCH_FIRST_CUSTOM_BIND + 8; j++) { if(j < RARCH_FIRST_CUSTOM_BIND) { fill_pathname_join_delim(btn_ident[j], s1, key_strings[j], '_', sizeof(btn_ident[j])); fill_pathname_join_delim(key_ident[j], s2, key_strings[j], '_', sizeof(btn_ident[j])); /* only save values that have been modified */ if(settings->uints.input_remap_ids[i][j] != j && settings->uints.input_remap_ids[i][j] != RARCH_UNMAPPED) config_set_int(conf, btn_ident[j], settings->uints.input_remap_ids[i][j]); else if (settings->uints.input_remap_ids[i][j] != j && settings->uints.input_remap_ids[i][j] == RARCH_UNMAPPED) config_set_int(conf, btn_ident[j], -1); else config_unset(conf,btn_ident[j]); if (settings->uints.input_keymapper_ids[i][j] != RETROK_UNKNOWN) config_set_int(conf, key_ident[j], settings->uints.input_keymapper_ids[i][j]); } else { k = j - RARCH_FIRST_CUSTOM_BIND; fill_pathname_join_delim(stk_ident[k], s3, key_strings[j], '_', sizeof(stk_ident[k])); if(settings->uints.input_remap_ids[i][j] != j && settings->uints.input_remap_ids[i][j] != RARCH_UNMAPPED) config_set_int(conf, stk_ident[k], settings->uints.input_remap_ids[i][j]); else if(settings->uints.input_remap_ids[i][j] != j && settings->uints.input_remap_ids[i][j] == RARCH_UNMAPPED) config_set_int(conf, stk_ident[k], -1); else config_unset(conf, stk_ident[k]); } } snprintf(s1, sizeof(s1), "input_libretro_device_p%u", i + 1); config_set_int(conf, s1, input_config_get_device(i)); snprintf(s1, sizeof(s1), "input_player%u_analog_dpad_mode", i + 1); config_set_int(conf, s1, settings->uints.input_analog_dpad_mode[i]); } ret = config_file_write(conf, remap_file); config_file_free(conf); free(remap_file); return ret; }
int secure_write () { return config_file_write (secure_config_file); }
int plugin_config_write () { return config_file_write (plugin_config_file); }
/** * menu_shader_manager_save_preset: * @basename : basename of preset * @apply : immediately set preset after saving * * Save a shader preset to disk. **/ bool menu_shader_manager_save_preset( const char *basename, bool apply, bool fullpath) { #ifdef HAVE_SHADER_MANAGER char buffer[PATH_MAX_LENGTH]; char config_directory[PATH_MAX_LENGTH]; char preset_path[PATH_MAX_LENGTH]; unsigned d, type = RARCH_SHADER_NONE; const char *dirs[3] = {0}; config_file_t *conf = NULL; bool ret = false; struct video_shader *shader = NULL; settings_t *settings = config_get_ptr(); menu_handle_t *menu = NULL; buffer[0] = config_directory[0] = '\0'; preset_path[0] = '\0'; if (!menu_driver_ctl(RARCH_MENU_CTL_DRIVER_DATA_GET, &menu)) { RARCH_ERR("Cannot save shader preset.\n"); return false; } menu_driver_ctl(RARCH_MENU_CTL_SHADER_GET, &shader); if (!shader) return false; type = menu_shader_manager_get_type(shader); if (type == RARCH_SHADER_NONE) return false; *config_directory = '\0'; if (basename) { strlcpy(buffer, basename, sizeof(buffer)); /* Append extension automatically as appropriate. */ if ( !strstr(basename, file_path_str(FILE_PATH_CGP_EXTENSION)) && !strstr(basename, file_path_str(FILE_PATH_GLSLP_EXTENSION)) && !strstr(basename, file_path_str(FILE_PATH_SLANGP_EXTENSION))) { switch (type) { case RARCH_SHADER_GLSL: strlcat(buffer, file_path_str(FILE_PATH_GLSLP_EXTENSION), sizeof(buffer)); break; case RARCH_SHADER_SLANG: strlcat(buffer, file_path_str(FILE_PATH_SLANGP_EXTENSION), sizeof(buffer)); break; case RARCH_SHADER_CG: strlcat(buffer, file_path_str(FILE_PATH_CGP_EXTENSION), sizeof(buffer)); break; } } } else { const char *conf_path = NULL; switch (type) { case RARCH_SHADER_GLSL: conf_path = default_glslp; break; case RARCH_SHADER_SLANG: conf_path = default_slangp; break; default: case RARCH_SHADER_CG: conf_path = default_cgp; break; } if (!string_is_empty(conf_path)) strlcpy(buffer, conf_path, sizeof(buffer)); } if (!path_is_empty(RARCH_PATH_CONFIG)) fill_pathname_basedir( config_directory, path_get(RARCH_PATH_CONFIG), sizeof(config_directory)); if (!fullpath) { dirs[0] = settings->directory.video_shader; dirs[1] = settings->directory.menu_config; dirs[2] = config_directory; } if (!(conf = (config_file_t*)config_file_new(NULL))) return false; video_shader_write_conf_cgp(conf, shader); if (!fullpath) { for (d = 0; d < ARRAY_SIZE(dirs); d++) { if (!*dirs[d]) continue; fill_pathname_join(preset_path, dirs[d], buffer, sizeof(preset_path)); if (config_file_write(conf, preset_path)) { RARCH_LOG("Saved shader preset to %s.\n", preset_path); if (apply) menu_shader_manager_set_preset(NULL, type, preset_path); ret = true; break; } else RARCH_LOG("Failed writing shader preset to %s.\n", preset_path); } } else { if (!string_is_empty(basename)) strlcpy(preset_path, buffer, sizeof(preset_path)); if (config_file_write(conf, preset_path)) { RARCH_LOG("Saved shader preset to %s.\n", preset_path); if (apply) menu_shader_manager_set_preset(NULL, type, preset_path); ret = true; } else RARCH_LOG("Failed writing shader preset to %s.\n", preset_path); } config_file_free(conf); if (ret) return true; RARCH_ERR("Failed to save shader preset. Make sure config directory" " and/or shader dir are writable.\n"); #endif return false; }
void rarch_config_save(const char * conf_name) { config_file_t * conf = config_file_new(conf_name); if(!conf) { RARCH_ERR("Failed to write config file to \"%s\". Check permissions.\n", conf_name); return; } // g_settings config_set_string(conf, "libretro_path", g_settings.libretro); #ifdef HAVE_XML config_set_string(conf, "cheat_database_path", g_settings.cheat_database); #endif config_set_bool(conf, "rewind_enable", g_settings.rewind_enable); config_set_string(conf, "video_cg_shader", g_settings.video.cg_shader_path); config_set_float(conf, "video_aspect_ratio", g_settings.video.aspect_ratio); #ifdef HAVE_FBO config_set_float(conf, "video_fbo_scale_x", g_settings.video.fbo.scale_x); config_set_float(conf, "video_fbo_scale_y", g_settings.video.fbo.scale_y); config_set_string(conf, "video_second_pass_shader", g_settings.video.second_pass_shader); config_set_bool(conf, "video_render_to_texture", g_settings.video.render_to_texture); config_set_bool(conf, "video_second_pass_smooth", g_settings.video.second_pass_smooth); config_set_bool(conf, "fbo_enabled", g_settings.video.fbo.enable); #endif config_set_bool(conf, "video_smooth", g_settings.video.smooth); config_set_bool(conf, "video_vsync", g_settings.video.vsync); config_set_int(conf, "aspect_ratio_index", g_settings.video.aspect_ratio_idx); config_set_int(conf, "color_format", g_settings.video.color_format); config_set_string(conf, "audio_device", g_settings.audio.device); config_set_bool(conf, "audio_rate_control", g_settings.audio.rate_control); config_set_float(conf, "audio_rate_control_delta", g_settings.audio.rate_control_delta); for (unsigned i = 0; i < 7; i++) { char cfg[64]; snprintf(cfg, sizeof(cfg), "input_dpad_emulation_p%u", i + 1); config_set_int(conf, cfg, g_settings.input.dpad_emulation[i]); snprintf(cfg, sizeof(cfg), "input_device_p%u", i + 1); config_set_int(conf, cfg, g_settings.input.device[i]); } config_set_bool(conf, "overscan_enable", g_extern.console.screen.state.overscan.enable); config_set_bool(conf, "screenshots_enable", g_extern.console.screen.state.screenshots.enable); config_set_bool(conf, "gamma_correction", g_extern.console.screen.gamma_correction); #ifdef _XBOX1 config_set_int(conf, "flicker_filter", g_extern.console.screen.state.flicker_filter.value); config_set_int(conf, "sound_volume_level", g_extern.console.sound.volume_level); #endif config_set_bool(conf, "throttle_enable", g_extern.console.screen.state.throttle.enable); config_set_bool(conf, "triple_buffering_enable", g_extern.console.screen.state.triple_buffering.enable); config_set_bool(conf, "info_msg_enable", g_extern.console.rmenu.state.msg_info.enable); config_set_int(conf, "current_resolution_id", g_extern.console.screen.resolutions.current.id); config_set_int(conf, "custom_viewport_width", g_extern.console.screen.viewports.custom_vp.width); config_set_int(conf, "custom_viewport_height", g_extern.console.screen.viewports.custom_vp.height); config_set_int(conf, "custom_viewport_x", g_extern.console.screen.viewports.custom_vp.x); config_set_int(conf, "custom_viewport_y", g_extern.console.screen.viewports.custom_vp.y); config_set_string(conf, "default_rom_startup_dir", g_extern.console.main_wrap.paths.default_rom_startup_dir); config_set_float(conf, "menu_font_size", g_extern.console.rmenu.font_size); config_set_float(conf, "overscan_amount", g_extern.console.screen.overscan_amount); #ifdef HAVE_ZLIB config_set_int(conf, "zip_extract_mode", g_extern.file_state.zip_extract_mode); #endif // g_extern config_set_int(conf, "sound_mode", g_extern.console.sound.mode); config_set_int(conf, "state_slot", g_extern.state_slot); config_set_int(conf, "audio_mute", g_extern.audio_data.mute); config_set_bool(conf, "soft_display_filter_enable", g_extern.console.screen.state.soft_filter.enable); config_set_int(conf, "screen_orientation", g_extern.console.screen.orientation); config_set_bool(conf, "custom_bgm_enable", g_extern.console.sound.custom_bgm.enable); if (!config_file_write(conf, conf_name)) RARCH_ERR("Failed to write config file to \"%s\". Check permissions.\n", conf_name); free(conf); }
/** * input_remapping_save_file: * @path : Path to remapping file (relative path). * * Saves remapping values to file. * * Returns: true (1) if successful, otherwise false (0). **/ bool input_remapping_save_file(const char *path) { bool ret; unsigned i, j; char buf[PATH_MAX_LENGTH] = {0}; char remap_file[PATH_MAX_LENGTH] = {0}; config_file_t *conf = NULL; settings_t *settings = config_get_ptr(); fill_pathname_join(buf, settings->directory.input_remapping, path, sizeof(buf)); fill_pathname_noext(remap_file, buf, ".rmp", sizeof(remap_file)); conf = config_file_new(remap_file); if (!conf) { conf = config_file_new(NULL); if (!conf) return false; } for (i = 0; i < settings->input.max_users; i++) { char buf[64] = {0}; char key_ident[RARCH_FIRST_CUSTOM_BIND + 4][128] = {{0}}; char key_strings[RARCH_FIRST_CUSTOM_BIND + 4][128] = { "b", "y", "select", "start", "up", "down", "left", "right", "a", "x", "l", "r", "l2", "r2", "l3", "r3", "l_x", "l_y", "r_x", "r_y" }; snprintf(buf, sizeof(buf), "input_player%u", i + 1); for (j = 0; j < RARCH_FIRST_CUSTOM_BIND + 4; j++) { fill_pathname_join_delim(key_ident[j], buf, key_strings[j], '_', sizeof(key_ident[j])); /* only save values that have been modified */ if(j < RARCH_FIRST_CUSTOM_BIND) { if(settings->input.remap_ids[i][j] != j) config_set_int(conf, key_ident[j], settings->input.remap_ids[i][j]); else config_unset(conf,key_ident[j]); } else { if(settings->input.remap_ids[i][j] != j - RARCH_FIRST_CUSTOM_BIND) config_set_int(conf, key_ident[j], settings->input.remap_ids[i][j]); else config_unset(conf,key_ident[j]); } } snprintf(buf, sizeof(buf), "input_libretro_device_p%u", i + 1); config_set_int(conf, buf, settings->input.libretro_device[i]); snprintf(buf, sizeof(buf), "input_player%u_analog_dpad_mode", i + 1); config_set_int(conf, buf, settings->input.analog_dpad_mode[i]); } ret = config_file_write(conf, remap_file); config_file_free(conf); return ret; }
int menu_set_settings(unsigned setting, unsigned action) { unsigned port = rgui->current_pad; switch (setting) { case RGUI_START_SCREEN: if (action == RGUI_ACTION_OK) rgui_list_push(rgui->menu_stack, "", RGUI_START_SCREEN, 0); break; case RGUI_SETTINGS_REWIND_ENABLE: if (action == RGUI_ACTION_OK || action == RGUI_ACTION_LEFT || action == RGUI_ACTION_RIGHT) { settings_set(1ULL << S_REWIND); if (g_settings.rewind_enable) rarch_init_rewind(); else rarch_deinit_rewind(); } else if (action == RGUI_ACTION_START) { g_settings.rewind_enable = false; rarch_deinit_rewind(); } break; #ifdef HAVE_SCREENSHOTS case RGUI_SETTINGS_GPU_SCREENSHOT: if (action == RGUI_ACTION_OK || action == RGUI_ACTION_LEFT || action == RGUI_ACTION_RIGHT) g_settings.video.gpu_screenshot = !g_settings.video.gpu_screenshot; else if (action == RGUI_ACTION_START) g_settings.video.gpu_screenshot = true; break; #endif case RGUI_SETTINGS_REWIND_GRANULARITY: if (action == RGUI_ACTION_OK || action == RGUI_ACTION_RIGHT) settings_set(1ULL << S_REWIND_GRANULARITY_INCREMENT); else if (action == RGUI_ACTION_LEFT) settings_set(1ULL << S_REWIND_GRANULARITY_DECREMENT); else if (action == RGUI_ACTION_START) settings_set(1ULL << S_DEF_REWIND_GRANULARITY); break; case RGUI_SETTINGS_CONFIG_SAVE_ON_EXIT: if (action == RGUI_ACTION_OK || action == RGUI_ACTION_RIGHT || action == RGUI_ACTION_LEFT) { g_extern.config_save_on_exit = !g_extern.config_save_on_exit; } else if (action == RGUI_ACTION_START) g_extern.config_save_on_exit = true; break; #if defined(HAVE_THREADS) && !defined(RARCH_CONSOLE) case RGUI_SETTINGS_SRAM_AUTOSAVE: if (action == RGUI_ACTION_OK || action == RGUI_ACTION_RIGHT || action == RGUI_ACTION_LEFT) { rarch_deinit_autosave(); g_settings.autosave_interval = (!g_settings.autosave_interval) * 10; if (g_settings.autosave_interval) rarch_init_autosave(); } else if (action == RGUI_ACTION_START) { rarch_deinit_autosave(); g_settings.autosave_interval = 0; } break; #endif case RGUI_SETTINGS_SAVESTATE_SAVE: case RGUI_SETTINGS_SAVESTATE_LOAD: if (action == RGUI_ACTION_OK) { if (setting == RGUI_SETTINGS_SAVESTATE_SAVE) rarch_save_state(); else rarch_load_state(); g_extern.lifecycle_mode_state |= (1ULL << MODE_GAME); return -1; } else if (action == RGUI_ACTION_START) settings_set(1ULL << S_DEF_SAVE_STATE); else if (action == RGUI_ACTION_LEFT) settings_set(1ULL << S_SAVESTATE_DECREMENT); else if (action == RGUI_ACTION_RIGHT) settings_set(1ULL << S_SAVESTATE_INCREMENT); break; #ifdef HAVE_SCREENSHOTS case RGUI_SETTINGS_SCREENSHOT: if (action == RGUI_ACTION_OK) rarch_take_screenshot(); break; #endif case RGUI_SETTINGS_RESTART_GAME: if (action == RGUI_ACTION_OK) { rarch_game_reset(); g_extern.lifecycle_mode_state |= (1ULL << MODE_GAME); return -1; } break; case RGUI_SETTINGS_AUDIO_MUTE: if (action == RGUI_ACTION_START) settings_set(1ULL << S_DEF_AUDIO_MUTE); else settings_set(1ULL << S_AUDIO_MUTE); break; case RGUI_SETTINGS_AUDIO_CONTROL_RATE_DELTA: if (action == RGUI_ACTION_START) settings_set(1ULL << S_DEF_AUDIO_CONTROL_RATE); else if (action == RGUI_ACTION_LEFT) settings_set(1ULL << S_AUDIO_CONTROL_RATE_DECREMENT); else if (action == RGUI_ACTION_RIGHT) settings_set(1ULL << S_AUDIO_CONTROL_RATE_INCREMENT); break; case RGUI_SETTINGS_DEBUG_TEXT: if (action == RGUI_ACTION_START) g_settings.fps_show = false; else if (action == RGUI_ACTION_LEFT || action == RGUI_ACTION_RIGHT) g_settings.fps_show = !g_settings.fps_show; break; case RGUI_SETTINGS_DISK_INDEX: { const struct retro_disk_control_callback *control = &g_extern.system.disk_control; unsigned num_disks = control->get_num_images(); unsigned current = control->get_image_index(); int step = 0; if (action == RGUI_ACTION_RIGHT || action == RGUI_ACTION_OK) step = 1; else if (action == RGUI_ACTION_LEFT) step = -1; if (step) { unsigned next_index = (current + num_disks + 1 + step) % (num_disks + 1); rarch_disk_control_set_eject(true, false); rarch_disk_control_set_index(next_index); rarch_disk_control_set_eject(false, false); } break; } case RGUI_SETTINGS_RESTART_EMULATOR: if (action == RGUI_ACTION_OK) { #if defined(GEKKO) && defined(HW_RVL) fill_pathname_join(g_extern.fullpath, default_paths.core_dir, SALAMANDER_FILE, sizeof(g_extern.fullpath)); #endif g_extern.lifecycle_mode_state &= ~(1ULL << MODE_GAME); g_extern.lifecycle_mode_state |= (1ULL << MODE_EXITSPAWN); return -1; } break; case RGUI_SETTINGS_RESUME_GAME: if (action == RGUI_ACTION_OK) { g_extern.lifecycle_mode_state |= (1ULL << MODE_GAME); return -1; } break; case RGUI_SETTINGS_QUIT_RARCH: if (action == RGUI_ACTION_OK) { g_extern.lifecycle_mode_state &= ~(1ULL << MODE_GAME); return -1; } break; case RGUI_SETTINGS_SAVE_CONFIG: if (action == RGUI_ACTION_OK) menu_save_new_config(); break; #ifdef HAVE_OVERLAY case RGUI_SETTINGS_OVERLAY_PRESET: switch (action) { case RGUI_ACTION_OK: rgui_list_push(rgui->menu_stack, g_extern.overlay_dir, setting, rgui->selection_ptr); rgui->selection_ptr = 0; rgui->need_refresh = true; break; #ifndef __QNX__ // FIXME: Why ifndef QNX? case RGUI_ACTION_START: if (driver.overlay) input_overlay_free(driver.overlay); driver.overlay = NULL; *g_settings.input.overlay = '\0'; break; #endif default: break; } break; case RGUI_SETTINGS_OVERLAY_OPACITY: { bool changed = true; switch (action) { case RGUI_ACTION_LEFT: settings_set(1ULL << S_INPUT_OVERLAY_OPACITY_DECREMENT); break; case RGUI_ACTION_RIGHT: case RGUI_ACTION_OK: settings_set(1ULL << S_INPUT_OVERLAY_OPACITY_INCREMENT); break; case RGUI_ACTION_START: settings_set(1ULL << S_DEF_INPUT_OVERLAY_OPACITY); break; default: changed = false; break; } if (changed && driver.overlay) input_overlay_set_alpha_mod(driver.overlay, g_settings.input.overlay_opacity); break; } case RGUI_SETTINGS_OVERLAY_SCALE: { bool changed = true; switch (action) { case RGUI_ACTION_LEFT: settings_set(1ULL << S_INPUT_OVERLAY_SCALE_DECREMENT); break; case RGUI_ACTION_RIGHT: case RGUI_ACTION_OK: settings_set(1ULL << S_INPUT_OVERLAY_SCALE_INCREMENT); break; case RGUI_ACTION_START: settings_set(1ULL << S_DEF_INPUT_OVERLAY_SCALE); break; default: changed = false; break; } if (changed && driver.overlay) input_overlay_set_scale_factor(driver.overlay, g_settings.input.overlay_scale); break; } #endif // controllers case RGUI_SETTINGS_BIND_PLAYER: if (action == RGUI_ACTION_START) rgui->current_pad = 0; else if (action == RGUI_ACTION_LEFT) { if (rgui->current_pad != 0) rgui->current_pad--; } else if (action == RGUI_ACTION_RIGHT) { if (rgui->current_pad < MAX_PLAYERS - 1) rgui->current_pad++; } #ifdef HAVE_RGUI if (port != rgui->current_pad) rgui->need_refresh = true; #endif port = rgui->current_pad; break; case RGUI_SETTINGS_BIND_DEVICE: // If set_keybinds is supported, we do it more fancy, and scroll through // a list of supported devices directly. if (driver.input->set_keybinds) { g_settings.input.device[port] += DEVICE_LAST; if (action == RGUI_ACTION_START) g_settings.input.device[port] = 0; else if (action == RGUI_ACTION_LEFT) g_settings.input.device[port]--; else if (action == RGUI_ACTION_RIGHT) g_settings.input.device[port]++; // DEVICE_LAST can be 0, avoid modulo. if (g_settings.input.device[port] >= DEVICE_LAST) g_settings.input.device[port] -= DEVICE_LAST; unsigned keybind_action = (1ULL << KEYBINDS_ACTION_SET_DEFAULT_BINDS); driver.input->set_keybinds(driver.input_data, g_settings.input.device[port], port, 0, keybind_action); } else { // When only straight g_settings.input.joypad_map[] style // mapping is supported. int *p = &g_settings.input.joypad_map[port]; if (action == RGUI_ACTION_START) *p = port; else if (action == RGUI_ACTION_LEFT) (*p)--; else if (action == RGUI_ACTION_RIGHT) (*p)++; if (*p < -1) *p = -1; else if (*p >= MAX_PLAYERS) *p = MAX_PLAYERS - 1; } break; case RGUI_SETTINGS_BIND_DEVICE_TYPE: { static const unsigned device_types[] = { RETRO_DEVICE_NONE, RETRO_DEVICE_JOYPAD, RETRO_DEVICE_ANALOG, RETRO_DEVICE_MOUSE, RETRO_DEVICE_JOYPAD_MULTITAP, RETRO_DEVICE_LIGHTGUN_SUPER_SCOPE, RETRO_DEVICE_LIGHTGUN_JUSTIFIER, RETRO_DEVICE_LIGHTGUN_JUSTIFIERS, }; unsigned current_device, current_index, i; current_device = g_settings.input.libretro_device[port]; current_index = 0; for (i = 0; i < ARRAY_SIZE(device_types); i++) { if (current_device == device_types[i]) { current_index = i; break; } } bool updated = true; switch (action) { case RGUI_ACTION_START: current_device = RETRO_DEVICE_JOYPAD; break; case RGUI_ACTION_LEFT: current_device = device_types[(current_index + ARRAY_SIZE(device_types) - 1) % ARRAY_SIZE(device_types)]; break; case RGUI_ACTION_RIGHT: case RGUI_ACTION_OK: current_device = device_types[(current_index + 1) % ARRAY_SIZE(device_types)]; break; default: updated = false; } if (updated) { g_settings.input.libretro_device[port] = current_device; pretro_set_controller_port_device(port, current_device); } break; } case RGUI_SETTINGS_CUSTOM_BIND_ALL: if (action == RGUI_ACTION_OK) { rgui->binds.target = &g_settings.input.binds[port][0]; rgui->binds.begin = RGUI_SETTINGS_BIND_BEGIN; rgui->binds.last = RGUI_SETTINGS_BIND_LAST; rgui_list_push(rgui->menu_stack, "", RGUI_SETTINGS_CUSTOM_BIND, rgui->selection_ptr); menu_poll_bind_get_rested_axes(&rgui->binds); menu_poll_bind_state(&rgui->binds); } break; case RGUI_SETTINGS_CUSTOM_BIND_DEFAULT_ALL: if (action == RGUI_ACTION_OK) { unsigned i; struct retro_keybind *target = &g_settings.input.binds[port][0]; rgui->binds.begin = RGUI_SETTINGS_BIND_BEGIN; rgui->binds.last = RGUI_SETTINGS_BIND_LAST; for (i = RGUI_SETTINGS_BIND_BEGIN; i <= RGUI_SETTINGS_BIND_LAST; i++, target++) { target->joykey = NO_BTN; target->joyaxis = AXIS_NONE; } } break; case RGUI_SETTINGS_BIND_UP: case RGUI_SETTINGS_BIND_DOWN: case RGUI_SETTINGS_BIND_LEFT: case RGUI_SETTINGS_BIND_RIGHT: case RGUI_SETTINGS_BIND_A: case RGUI_SETTINGS_BIND_B: case RGUI_SETTINGS_BIND_X: case RGUI_SETTINGS_BIND_Y: case RGUI_SETTINGS_BIND_START: case RGUI_SETTINGS_BIND_SELECT: case RGUI_SETTINGS_BIND_L: case RGUI_SETTINGS_BIND_R: case RGUI_SETTINGS_BIND_L2: case RGUI_SETTINGS_BIND_R2: case RGUI_SETTINGS_BIND_L3: case RGUI_SETTINGS_BIND_R3: case RGUI_SETTINGS_BIND_ANALOG_LEFT_X_PLUS: case RGUI_SETTINGS_BIND_ANALOG_LEFT_X_MINUS: case RGUI_SETTINGS_BIND_ANALOG_LEFT_Y_PLUS: case RGUI_SETTINGS_BIND_ANALOG_LEFT_Y_MINUS: case RGUI_SETTINGS_BIND_ANALOG_RIGHT_X_PLUS: case RGUI_SETTINGS_BIND_ANALOG_RIGHT_X_MINUS: case RGUI_SETTINGS_BIND_ANALOG_RIGHT_Y_PLUS: case RGUI_SETTINGS_BIND_ANALOG_RIGHT_Y_MINUS: case RGUI_SETTINGS_BIND_MENU_TOGGLE: if (driver.input->set_keybinds) { unsigned keybind_action = KEYBINDS_ACTION_NONE; if (action == RGUI_ACTION_START) keybind_action = (1ULL << KEYBINDS_ACTION_SET_DEFAULT_BIND); // FIXME: The array indices here look totally wrong ... Fixed it so it looks kind of sane for now. if (keybind_action != KEYBINDS_ACTION_NONE) driver.input->set_keybinds(driver.input_data, g_settings.input.device[port], port, setting - RGUI_SETTINGS_BIND_BEGIN, keybind_action); } else { struct retro_keybind *bind = &g_settings.input.binds[port][setting - RGUI_SETTINGS_BIND_BEGIN]; if (action == RGUI_ACTION_OK) { rgui->binds.begin = setting; rgui->binds.last = setting; rgui->binds.target = bind; rgui->binds.player = port; rgui_list_push(rgui->menu_stack, "", RGUI_SETTINGS_CUSTOM_BIND, rgui->selection_ptr); menu_poll_bind_get_rested_axes(&rgui->binds); menu_poll_bind_state(&rgui->binds); } else if (action == RGUI_ACTION_START) { bind->joykey = NO_BTN; bind->joyaxis = AXIS_NONE; } } break; case RGUI_BROWSER_DIR_PATH: if (action == RGUI_ACTION_START) { *g_settings.rgui_browser_directory = '\0'; *rgui->base_path = '\0'; } break; #ifdef HAVE_SCREENSHOTS case RGUI_SCREENSHOT_DIR_PATH: if (action == RGUI_ACTION_START) *g_settings.screenshot_directory = '\0'; break; #endif case RGUI_SAVEFILE_DIR_PATH: if (action == RGUI_ACTION_START) *g_extern.savefile_dir = '\0'; break; #ifdef HAVE_OVERLAY case RGUI_OVERLAY_DIR_PATH: if (action == RGUI_ACTION_START) *g_extern.overlay_dir = '\0'; break; #endif case RGUI_SAVESTATE_DIR_PATH: if (action == RGUI_ACTION_START) *g_extern.savestate_dir = '\0'; break; #ifdef HAVE_DYNAMIC case RGUI_LIBRETRO_DIR_PATH: if (action == RGUI_ACTION_START) { *rgui->libretro_dir = '\0'; menu_init_core_info(rgui); } break; #endif case RGUI_LIBRETRO_INFO_DIR_PATH: if (action == RGUI_ACTION_START) { *g_settings.libretro_info_path = '\0'; menu_init_core_info(rgui); } break; case RGUI_CONFIG_DIR_PATH: if (action == RGUI_ACTION_START) *g_settings.rgui_config_directory = '\0'; break; case RGUI_SHADER_DIR_PATH: if (action == RGUI_ACTION_START) *g_settings.video.shader_dir = '\0'; break; case RGUI_SYSTEM_DIR_PATH: if (action == RGUI_ACTION_START) *g_settings.system_directory = '\0'; break; case RGUI_SETTINGS_VIDEO_ROTATION: if (action == RGUI_ACTION_START) { settings_set(1ULL << S_DEF_ROTATION); video_set_rotation_func((g_settings.video.rotation + g_extern.system.rotation) % 4); } else if (action == RGUI_ACTION_LEFT) { settings_set(1ULL << S_ROTATION_DECREMENT); video_set_rotation_func((g_settings.video.rotation + g_extern.system.rotation) % 4); } else if (action == RGUI_ACTION_RIGHT) { settings_set(1ULL << S_ROTATION_INCREMENT); video_set_rotation_func((g_settings.video.rotation + g_extern.system.rotation) % 4); } break; case RGUI_SETTINGS_VIDEO_FILTER: if (action == RGUI_ACTION_START) settings_set(1ULL << S_DEF_HW_TEXTURE_FILTER); else settings_set(1ULL << S_HW_TEXTURE_FILTER); if (driver.video_poke->set_filtering) driver.video_poke->set_filtering(driver.video_data, 1, g_settings.video.smooth); break; case RGUI_SETTINGS_VIDEO_GAMMA: if (action == RGUI_ACTION_START) { g_extern.console.screen.gamma_correction = 0; if (driver.video_poke->apply_state_changes) driver.video_poke->apply_state_changes(driver.video_data); } else if (action == RGUI_ACTION_LEFT) { if(g_extern.console.screen.gamma_correction > 0) { g_extern.console.screen.gamma_correction--; if (driver.video_poke->apply_state_changes) driver.video_poke->apply_state_changes(driver.video_data); } } else if (action == RGUI_ACTION_RIGHT) { if(g_extern.console.screen.gamma_correction < MAX_GAMMA_SETTING) { g_extern.console.screen.gamma_correction++; if (driver.video_poke->apply_state_changes) driver.video_poke->apply_state_changes(driver.video_data); } } break; case RGUI_SETTINGS_VIDEO_INTEGER_SCALE: if (action == RGUI_ACTION_START) settings_set(1ULL << S_DEF_SCALE_INTEGER); else if (action == RGUI_ACTION_LEFT || action == RGUI_ACTION_RIGHT || action == RGUI_ACTION_OK) settings_set(1ULL << S_SCALE_INTEGER_TOGGLE); if (driver.video_poke->apply_state_changes) driver.video_poke->apply_state_changes(driver.video_data); break; case RGUI_SETTINGS_VIDEO_ASPECT_RATIO: if (action == RGUI_ACTION_START) settings_set(1ULL << S_DEF_ASPECT_RATIO); else if (action == RGUI_ACTION_LEFT) settings_set(1ULL << S_ASPECT_RATIO_DECREMENT); else if (action == RGUI_ACTION_RIGHT) settings_set(1ULL << S_ASPECT_RATIO_INCREMENT); if (driver.video_poke->set_aspect_ratio) driver.video_poke->set_aspect_ratio(driver.video_data, g_settings.video.aspect_ratio_idx); break; case RGUI_SETTINGS_TOGGLE_FULLSCREEN: if (action == RGUI_ACTION_OK) rarch_set_fullscreen(!g_settings.video.fullscreen); break; #if defined(GEKKO) case RGUI_SETTINGS_VIDEO_RESOLUTION: if (action == RGUI_ACTION_LEFT) { if(rgui_current_gx_resolution > 0) { rgui_current_gx_resolution--; gx_set_video_mode(rgui_gx_resolutions[rgui_current_gx_resolution][0], rgui_gx_resolutions[rgui_current_gx_resolution][1]); } } else if (action == RGUI_ACTION_RIGHT) { if (rgui_current_gx_resolution < GX_RESOLUTIONS_LAST - 1) { #ifdef HW_RVL if ((rgui_current_gx_resolution + 1) > GX_RESOLUTIONS_640_480) if (CONF_GetVideo() != CONF_VIDEO_PAL) return 0; #endif rgui_current_gx_resolution++; gx_set_video_mode(rgui_gx_resolutions[rgui_current_gx_resolution][0], rgui_gx_resolutions[rgui_current_gx_resolution][1]); } } break; #elif defined(__CELLOS_LV2__) case RGUI_SETTINGS_VIDEO_RESOLUTION: if (action == RGUI_ACTION_LEFT) settings_set(1ULL << S_RESOLUTION_PREVIOUS); else if (action == RGUI_ACTION_RIGHT) settings_set(1ULL << S_RESOLUTION_NEXT); else if (action == RGUI_ACTION_OK) { if (g_extern.console.screen.resolutions.list[g_extern.console.screen.resolutions.current.idx] == CELL_VIDEO_OUT_RESOLUTION_576) { if (g_extern.console.screen.pal_enable) g_extern.lifecycle_mode_state |= (1ULL<< MODE_VIDEO_PAL_ENABLE); } else { g_extern.lifecycle_mode_state &= ~(1ULL << MODE_VIDEO_PAL_ENABLE); g_extern.lifecycle_mode_state &= ~(1ULL << MODE_VIDEO_PAL_TEMPORAL_ENABLE); } driver.video->restart(); rgui_init_textures(); } break; #endif #ifdef HW_RVL case RGUI_SETTINGS_VIDEO_SOFT_FILTER: if (g_extern.lifecycle_mode_state & (1ULL << MODE_VIDEO_SOFT_FILTER_ENABLE)) g_extern.lifecycle_mode_state &= ~(1ULL << MODE_VIDEO_SOFT_FILTER_ENABLE); else g_extern.lifecycle_mode_state |= (1ULL << MODE_VIDEO_SOFT_FILTER_ENABLE); if (driver.video_poke->apply_state_changes) driver.video_poke->apply_state_changes(driver.video_data); break; #endif case RGUI_SETTINGS_VIDEO_VSYNC: switch (action) { case RGUI_ACTION_START: settings_set(1ULL << S_DEF_VIDEO_VSYNC); break; case RGUI_ACTION_LEFT: case RGUI_ACTION_RIGHT: case RGUI_ACTION_OK: settings_set(1ULL << S_VIDEO_VSYNC_TOGGLE); break; default: break; } break; case RGUI_SETTINGS_VIDEO_HARD_SYNC: switch (action) { case RGUI_ACTION_START: g_settings.video.hard_sync = false; break; case RGUI_ACTION_LEFT: case RGUI_ACTION_RIGHT: case RGUI_ACTION_OK: g_settings.video.hard_sync = !g_settings.video.hard_sync; break; default: break; } break; case RGUI_SETTINGS_VIDEO_BLACK_FRAME_INSERTION: switch (action) { case RGUI_ACTION_START: g_settings.video.black_frame_insertion = false; break; case RGUI_ACTION_LEFT: case RGUI_ACTION_RIGHT: case RGUI_ACTION_OK: g_settings.video.black_frame_insertion = !g_settings.video.black_frame_insertion; break; default: break; } break; case RGUI_SETTINGS_VIDEO_CROP_OVERSCAN: switch (action) { case RGUI_ACTION_START: g_settings.video.crop_overscan = true; break; case RGUI_ACTION_LEFT: case RGUI_ACTION_RIGHT: case RGUI_ACTION_OK: g_settings.video.crop_overscan = !g_settings.video.crop_overscan; break; default: break; } break; case RGUI_SETTINGS_VIDEO_WINDOW_SCALE_X: case RGUI_SETTINGS_VIDEO_WINDOW_SCALE_Y: { float *scale = setting == RGUI_SETTINGS_VIDEO_WINDOW_SCALE_X ? &g_settings.video.xscale : &g_settings.video.yscale; float old_scale = *scale; switch (action) { case RGUI_ACTION_START: *scale = 3.0f; break; case RGUI_ACTION_LEFT: *scale -= 1.0f; break; case RGUI_ACTION_RIGHT: *scale += 1.0f; break; default: break; } *scale = roundf(*scale); *scale = max(*scale, 1.0f); if (old_scale != *scale && !g_settings.video.fullscreen) rarch_set_fullscreen(g_settings.video.fullscreen); // Reinit video driver. break; } #ifdef HAVE_THREADS case RGUI_SETTINGS_VIDEO_THREADED: { bool old = g_settings.video.threaded; if (action == RGUI_ACTION_OK || action == RGUI_ACTION_LEFT || action == RGUI_ACTION_RIGHT) g_settings.video.threaded = !g_settings.video.threaded; else if (action == RGUI_ACTION_START) g_settings.video.threaded = false; if (g_settings.video.threaded != old) rarch_set_fullscreen(g_settings.video.fullscreen); // Reinit video driver. break; } #endif case RGUI_SETTINGS_VIDEO_SWAP_INTERVAL: { unsigned old = g_settings.video.swap_interval; switch (action) { case RGUI_ACTION_START: g_settings.video.swap_interval = 1; break; case RGUI_ACTION_LEFT: g_settings.video.swap_interval--; break; case RGUI_ACTION_RIGHT: case RGUI_ACTION_OK: g_settings.video.swap_interval++; break; default: break; } g_settings.video.swap_interval = min(g_settings.video.swap_interval, 4); g_settings.video.swap_interval = max(g_settings.video.swap_interval, 1); if (old != g_settings.video.swap_interval && driver.video && driver.video_data) video_set_nonblock_state_func(false); // This will update the current swap interval. Since we're in RGUI now, always apply VSync. break; } case RGUI_SETTINGS_VIDEO_HARD_SYNC_FRAMES: switch (action) { case RGUI_ACTION_START: g_settings.video.hard_sync_frames = 0; break; case RGUI_ACTION_LEFT: if (g_settings.video.hard_sync_frames > 0) g_settings.video.hard_sync_frames--; break; case RGUI_ACTION_RIGHT: case RGUI_ACTION_OK: if (g_settings.video.hard_sync_frames < 3) g_settings.video.hard_sync_frames++; break; default: break; } break; case RGUI_SETTINGS_VIDEO_REFRESH_RATE_AUTO: switch (action) { case RGUI_ACTION_START: g_extern.measure_data.frame_time_samples_count = 0; break; case RGUI_ACTION_OK: { double refresh_rate = 0.0; double deviation = 0.0; unsigned sample_points = 0; if (driver_monitor_fps_statistics(&refresh_rate, &deviation, &sample_points)) { driver_set_monitor_refresh_rate(refresh_rate); // Incase refresh rate update forced non-block video. video_set_nonblock_state_func(false); } break; } default: break; } break; #ifdef HAVE_SHADER_MANAGER case RGUI_SETTINGS_SHADER_PASSES: switch (action) { case RGUI_ACTION_START: rgui->shader.passes = 0; break; case RGUI_ACTION_LEFT: if (rgui->shader.passes) rgui->shader.passes--; break; case RGUI_ACTION_RIGHT: case RGUI_ACTION_OK: if (rgui->shader.passes < RGUI_MAX_SHADERS) rgui->shader.passes++; break; default: break; } #ifndef HAVE_RMENU rgui->need_refresh = true; #endif break; case RGUI_SETTINGS_SHADER_APPLY: { if (!driver.video->set_shader || action != RGUI_ACTION_OK) return 0; RARCH_LOG("Applying shader ...\n"); enum rarch_shader_type type = shader_manager_get_type(&rgui->shader); if (rgui->shader.passes && type != RARCH_SHADER_NONE) { const char *conf_path = type == RARCH_SHADER_GLSL ? rgui->default_glslp : rgui->default_cgp; char config_directory[PATH_MAX]; if (*g_extern.config_path) fill_pathname_basedir(config_directory, g_extern.config_path, sizeof(config_directory)); else *config_directory = '\0'; char cgp_path[PATH_MAX]; const char *dirs[] = { g_settings.video.shader_dir, g_settings.rgui_config_directory, config_directory, }; config_file_t *conf = config_file_new(NULL); if (!conf) return 0; gfx_shader_write_conf_cgp(conf, &rgui->shader); bool ret = false; unsigned d; for (d = 0; d < ARRAY_SIZE(dirs); d++) { if (!*dirs[d]) continue; fill_pathname_join(cgp_path, dirs[d], conf_path, sizeof(cgp_path)); if (config_file_write(conf, cgp_path)) { RARCH_LOG("Saved shader preset to %s.\n", cgp_path); shader_manager_set_preset(NULL, type, cgp_path); ret = true; break; } else RARCH_LOG("Failed writing shader preset to %s.\n", cgp_path); } config_file_free(conf); if (!ret) RARCH_ERR("Failed to save shader preset. Make sure config directory and/or shader dir are writable.\n"); } else { type = gfx_shader_parse_type("", DEFAULT_SHADER_TYPE); if (type == RARCH_SHADER_NONE) { #if defined(HAVE_GLSL) type = RARCH_SHADER_GLSL; #elif defined(HAVE_CG) || defined(HAVE_HLSL) type = RARCH_SHADER_CG; #endif } shader_manager_set_preset(NULL, type, NULL); } } break; #endif default: break; } return 0; }