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;
}
