/**
* task_load_content:
*
* Loads content into currently selected core.
* Will also optionally push the content entry to the history playlist.
*
* Returns: true (1) if successful, otherwise false (0).
**/
static bool task_load_content(content_ctx_info_t *content_info,
content_information_ctx_t *content_ctx,
bool launched_from_menu,
enum content_mode_load mode,
char **error_string)
{
char name[255];
char msg[255];
name[0] = msg[0] = '\0';
if (!content_load(content_info))
goto error;
/* Push entry to top of history playlist */
if (_content_is_inited || content_does_not_need_content())
{
char tmp[PATH_MAX_LENGTH];
struct retro_system_info *info = NULL;
rarch_system_info_t *sys_info = NULL;
tmp[0] = '\0';
runloop_ctl(RUNLOOP_CTL_SYSTEM_INFO_GET, &sys_info);
if (sys_info)
info = &sys_info->info;
#ifdef HAVE_MENU
if (launched_from_menu)
menu_driver_ctl(RARCH_MENU_CTL_SYSTEM_INFO_GET, &info);
#endif
strlcpy(tmp, path_get(RARCH_PATH_CONTENT), sizeof(tmp));
if (!launched_from_menu)
{
/* Path can be relative here.
* Ensure we're pushing absolute path. */
if (!string_is_empty(tmp))
path_resolve_realpath(tmp, sizeof(tmp));
}
if (info && !string_is_empty(tmp))
{
const char *core_path = NULL;
const char *core_name = NULL;
playlist_t *playlist_tmp = g_defaults.content_history;
switch (path_is_media_type(tmp))
{
case RARCH_CONTENT_MOVIE:
#ifdef HAVE_FFMPEG
playlist_tmp = g_defaults.video_history;
core_name = "movieplayer";
core_path = "builtin";
#endif
break;
case RARCH_CONTENT_MUSIC:
#ifdef HAVE_FFMPEG
playlist_tmp = g_defaults.music_history;
core_name = "musicplayer";
core_path = "builtin";
#endif
break;
case RARCH_CONTENT_IMAGE:
#ifdef HAVE_IMAGEVIEWER
playlist_tmp = g_defaults.image_history;
core_name = "imageviewer";
core_path = "builtin";
#endif
break;
default:
core_path = path_get(RARCH_PATH_CORE);
core_name = info->library_name;
break;
}
if (mode == CONTENT_MODE_LOAD_FROM_CLI)
{
settings_t *settings = config_get_ptr();
content_ctx->history_list_enable = settings->history_list_enable;
}
if (
content_ctx->history_list_enable
&& playlist_tmp
&& playlist_push(
playlist_tmp,
tmp,
NULL,
core_path,
core_name,
NULL,
NULL)
)
playlist_write_file(playlist_tmp);
}
}
return true;
error:
if (launched_from_menu)
{
if (!path_is_empty(RARCH_PATH_CONTENT) && !string_is_empty(name))
{
snprintf(msg, sizeof(msg), "%s %s.\n",
msg_hash_to_str(MSG_FAILED_TO_LOAD),
name);
if (error_string)
free(error_string);
*error_string = strdup(msg);
}
}
return false;
}
/* Updates path for specified thumbnail identifier (right, left).
* Must be called after:
* - menu_thumbnail_set_system()
* - menu_thumbnail_set_content*()
* ...and before:
* - menu_thumbnail_get_path()
* Returns true if generated path is valid */
bool menu_thumbnail_update_path(menu_thumbnail_path_data_t *path_data, enum menu_thumbnail_id thumbnail_id)
{
settings_t *settings = config_get_ptr();
const char *type = menu_thumbnail_get_type(thumbnail_id);
const char *system_name = NULL;
char *thumbnail_path = NULL;
char content_dir[PATH_MAX_LENGTH];
if (!path_data)
return false;
/* Determine which path we are updating... */
switch (thumbnail_id)
{
case MENU_THUMBNAIL_RIGHT:
thumbnail_path = path_data->right_path;
break;
case MENU_THUMBNAIL_LEFT:
thumbnail_path = path_data->left_path;
break;
default:
return false;
}
thumbnail_path[0] = '\0';
/* Sundry error checking */
if (!settings)
return false;
if (string_is_empty(settings->paths.directory_thumbnails))
return false;
if (!menu_thumbnail_is_enabled(thumbnail_id))
return false;
/* Generate new path */
/* > Check path_data for empty strings */
if (string_is_empty(path_data->content_path) ||
string_is_empty(path_data->content_img) ||
(string_is_empty(path_data->system) &&
string_is_empty(path_data->content_db_name)))
return false;
/* > Get current system */
if (string_is_empty(path_data->content_db_name))
{
/* If this is a content history or favorites playlist
* then the current 'path_data->system' string is
* meaningless. In this case, we fall back to the
* content directory name */
if (string_is_equal(path_data->system, "history") ||
string_is_equal(path_data->system, "favorites"))
{
char tmp_buf[PATH_MAX_LENGTH] = {0};
const char *last_slash = find_last_slash(path_data->content_path);
content_dir[0] = '\0';
system_name = content_dir;
if (last_slash)
{
size_t path_length = last_slash + 1 - path_data->content_path;
if ((path_length > 1) && (path_length < PATH_MAX_LENGTH))
{
strlcpy(tmp_buf, path_data->content_path, path_length * sizeof(char));
strlcpy(content_dir, path_basename(tmp_buf), sizeof(content_dir));
}
}
if (string_is_empty(system_name))
return false;
}
else
system_name = path_data->system;
}
else
system_name = path_data->content_db_name;
/* > Special case: thumbnail for imageviewer content
* is the image file itself */
if (string_is_equal(system_name, "images_history") ||
string_is_equal(path_data->content_core_name, "imageviewer"))
{
/* imageviewer content is identical for left and right thumbnails */
if (path_is_media_type(path_data->content_path) == RARCH_CONTENT_IMAGE)
strlcpy(thumbnail_path,
path_data->content_path, PATH_MAX_LENGTH * sizeof(char));
}
else
{
char tmp_buf[PATH_MAX_LENGTH];
tmp_buf[0] = '\0';
/* > Normal content: assemble path */
/* >> Base + system name */
fill_pathname_join(thumbnail_path, settings->paths.directory_thumbnails,
system_name, PATH_MAX_LENGTH * sizeof(char));
/* >> Add type */
fill_pathname_join(tmp_buf, thumbnail_path, type, sizeof(tmp_buf));
/* >> Add content image */
thumbnail_path[0] = '\0';
fill_pathname_join(thumbnail_path, tmp_buf,
path_data->content_img, PATH_MAX_LENGTH * sizeof(char));
}
/* Final error check - is cached path empty? */
if (string_is_empty(thumbnail_path))
return false;
return true;
}
/* Sets current thumbnail content to the specified image.
* Returns true if content is valid */
bool menu_thumbnail_set_content_image(menu_thumbnail_path_data_t *path_data, const char *img_dir, const char *img_name)
{
char *content_img_no_ext = NULL;
if (!path_data)
return false;
/* When content is updated, must regenerate right/left
* thumbnail paths */
path_data->right_path[0] = '\0';
path_data->left_path[0] = '\0';
/* 'Reset' path_data content strings */
path_data->content_path[0] = '\0';
path_data->content_label[0] = '\0';
path_data->content_core_name[0] = '\0';
path_data->content_db_name[0] = '\0';
path_data->content_img[0] = '\0';
if (string_is_empty(img_dir))
return false;
if (string_is_empty(img_name))
return false;
if (path_is_media_type(img_name) != RARCH_CONTENT_IMAGE)
return false;
/* Cache content image name */
strlcpy(path_data->content_img,
img_name, sizeof(path_data->content_img));
/* Get image label */
content_img_no_ext = path_remove_extension(path_data->content_img);
if (!string_is_empty(content_img_no_ext))
strlcpy(path_data->content_label,
content_img_no_ext, sizeof(path_data->content_label));
else
strlcpy(path_data->content_label,
path_data->content_img, sizeof(path_data->content_label));
/* Set file path */
fill_pathname_join(path_data->content_path,
img_dir, img_name, sizeof(path_data->content_path));
/* Set core name to "imageviewer" */
strlcpy(path_data->content_core_name,
"imageviewer", sizeof(path_data->content_core_name));
/* Set database name (arbitrarily) to "_images_"
* (required for compatibility with menu_thumbnail_update_path(),
* but not actually used...) */
strlcpy(path_data->content_db_name,
"_images_", sizeof(path_data->content_db_name));
/* Redundant error check */
if (string_is_empty(path_data->content_path))
return false;
return true;
}
/* Updates path for specified thumbnail identifier (right, left).
* Must be called after:
* - menu_thumbnail_set_system()
* - menu_thumbnail_set_content*()
* ...and before:
* - menu_thumbnail_get_path()
* Returns true if generated path is valid */
bool menu_thumbnail_update_path(menu_thumbnail_path_data_t *path_data, enum menu_thumbnail_id thumbnail_id)
{
settings_t *settings = config_get_ptr();
const char *type = menu_thumbnail_get_type(thumbnail_id);
const char *system_name = NULL;
char *thumbnail_path = NULL;
if (!path_data)
return false;
/* Determine which path we are updating... */
switch (thumbnail_id)
{
case MENU_THUMBNAIL_RIGHT:
thumbnail_path = path_data->right_path;
break;
case MENU_THUMBNAIL_LEFT:
thumbnail_path = path_data->left_path;
break;
default:
return false;
}
thumbnail_path[0] = '\0';
/* Sundry error checking */
if (!settings)
return false;
if (string_is_empty(settings->paths.directory_thumbnails))
return false;
if (!menu_thumbnail_is_enabled(thumbnail_id))
return false;
/* Generate new path */
/* > Check path_data for empty strings */
if (string_is_empty(path_data->content_img) ||
(string_is_empty(path_data->system) &&
string_is_empty(path_data->content_db_name)))
return false;
/* > Get current system */
system_name = string_is_empty(path_data->content_db_name) ?
path_data->system : path_data->content_db_name;
/* > Special case: thumbnail for imageviewer content
* is the image file itself */
if (string_is_equal(system_name, "images_history") ||
string_is_equal(path_data->content_core_name, "imageviewer"))
{
if (string_is_empty(path_data->content_path))
return false;
/* imageviewer content is identical for left and right thumbnails */
if (path_is_media_type(path_data->content_path) == RARCH_CONTENT_IMAGE)
strlcpy(thumbnail_path,
path_data->content_path, PATH_MAX_LENGTH * sizeof(char));
}
else
{
char tmp_buf[PATH_MAX_LENGTH];
tmp_buf[0] = '\0';
/* > Normal content: assemble path */
/* >> Base + system name */
fill_pathname_join(thumbnail_path, settings->paths.directory_thumbnails,
system_name, PATH_MAX_LENGTH * sizeof(char));
/* >> Add type */
fill_pathname_join(tmp_buf, thumbnail_path, type, sizeof(tmp_buf));
/* >> Add content image */
thumbnail_path[0] = '\0';
fill_pathname_join(thumbnail_path, tmp_buf,
path_data->content_img, PATH_MAX_LENGTH * sizeof(char));
}
/* Final error check - is cached path empty? */
if (string_is_empty(thumbnail_path))
return false;
return true;
}
/**
* task_load_content:
*
* Loads content into currently selected core.
* Will also optionally push the content entry to the history playlist.
*
* Returns: true (1) if successful, otherwise false (0).
**/
static bool task_load_content(content_ctx_info_t *content_info,
bool launched_from_menu,
enum content_mode_load mode)
{
char name[256];
char msg[256];
name[0] = msg[0] = '\0';
if (launched_from_menu)
{
#ifdef HAVE_MENU
/* redraw menu frame */
menu_display_set_msg_force(true);
menu_driver_ctl(RARCH_MENU_CTL_RENDER, NULL);
if (!path_is_empty(RARCH_PATH_CONTENT))
fill_pathname_base(name, path_get(RARCH_PATH_CONTENT), sizeof(name));
#endif
/** Show loading OSD message */
if (!string_is_empty(path_get(RARCH_PATH_CONTENT)))
{
snprintf(msg, sizeof(msg), "%s %s ...",
msg_hash_to_str(MSG_LOADING),
name);
runloop_msg_queue_push(msg, 2, 1, true);
}
}
if (!content_load(content_info))
goto error;
/* Push entry to top of history playlist */
if (content_is_inited() || content_does_not_need_content())
{
char tmp[PATH_MAX_LENGTH];
struct retro_system_info *info = NULL;
rarch_system_info_t *system = NULL;
tmp[0] = '\0';
runloop_ctl(RUNLOOP_CTL_SYSTEM_INFO_GET, &system);
if (system)
info = &system->info;
#ifdef HAVE_MENU
if (launched_from_menu)
menu_driver_ctl(RARCH_MENU_CTL_SYSTEM_INFO_GET, &info);
#endif
strlcpy(tmp, path_get(RARCH_PATH_CONTENT), sizeof(tmp));
if (!launched_from_menu)
{
/* Path can be relative here.
* Ensure we're pushing absolute path. */
if (!string_is_empty(tmp))
path_resolve_realpath(tmp, sizeof(tmp));
}
if (info && *tmp)
{
const char *core_path = NULL;
const char *core_name = NULL;
playlist_t *playlist_tmp = g_defaults.content_history;
switch (path_is_media_type(tmp))
{
case RARCH_CONTENT_MOVIE:
#ifdef HAVE_FFMPEG
playlist_tmp = g_defaults.video_history;
core_name = "movieplayer";
core_path = "builtin";
#endif
break;
case RARCH_CONTENT_MUSIC:
#ifdef HAVE_FFMPEG
playlist_tmp = g_defaults.music_history;
core_name = "musicplayer";
core_path = "builtin";
#endif
break;
case RARCH_CONTENT_IMAGE:
#ifdef HAVE_IMAGEVIEWER
playlist_tmp = g_defaults.image_history;
core_name = "imageviewer";
core_path = "builtin";
#endif
break;
default:
core_path = path_get(RARCH_PATH_CORE);
core_name = info->library_name;
break;
}
if (content_push_to_history_playlist(playlist_tmp, tmp,
core_name, core_path))
playlist_write_file(playlist_tmp);
}
}
return true;
error:
if (launched_from_menu)
{
if (!path_is_empty(RARCH_PATH_CONTENT) && !string_is_empty(name))
{
snprintf(msg, sizeof(msg), "%s %s.\n",
msg_hash_to_str(MSG_FAILED_TO_LOAD),
name);
runloop_msg_queue_push(msg, 2, 90, true);
}
}
return false;
}
void filebrowser_parse(void *data, unsigned type_data, bool extensions_honored)
{
size_t i, list_size;
struct string_list *str_list = NULL;
unsigned items_found = 0;
unsigned files_count = 0;
unsigned dirs_count = 0;
settings_t *settings = config_get_ptr();
menu_displaylist_info_t *info = (menu_displaylist_info_t*)data;
enum menu_displaylist_ctl_state type = (enum menu_displaylist_ctl_state)
type_data;
bool path_is_compressed = path_is_compressed_file(info->path);
bool filter_ext =
settings->menu.navigation.browser.filter.supported_extensions_enable;
if (string_is_equal(info->label,
msg_hash_to_str(MENU_ENUM_LABEL_SCAN_FILE)))
filter_ext = false;
if (extensions_honored)
filter_ext = true;
if (path_is_compressed)
str_list = file_archive_get_file_list(info->path, info->exts);
else
str_list = dir_list_new(info->path,
filter_ext ? info->exts : NULL,
true, settings->show_hidden_files, true, false);
#ifdef HAVE_LIBRETRODB
if (filebrowser_types == FILEBROWSER_SCAN_DIR)
menu_entries_prepend(info->list,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_SCAN_THIS_DIRECTORY),
msg_hash_to_str(MENU_ENUM_LABEL_SCAN_THIS_DIRECTORY),
MENU_ENUM_LABEL_SCAN_THIS_DIRECTORY,
FILE_TYPE_SCAN_DIRECTORY, 0 ,0);
#endif
if (filebrowser_types == FILEBROWSER_SELECT_DIR)
menu_entries_prepend(info->list,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_USE_THIS_DIRECTORY),
msg_hash_to_str(MENU_ENUM_LABEL_USE_THIS_DIRECTORY),
MENU_ENUM_LABEL_USE_THIS_DIRECTORY,
FILE_TYPE_USE_DIRECTORY, 0 ,0);
if (!str_list)
{
const char *str = path_is_compressed
? msg_hash_to_str(MENU_ENUM_LABEL_VALUE_UNABLE_TO_READ_COMPRESSED_FILE)
: msg_hash_to_str(MENU_ENUM_LABEL_VALUE_DIRECTORY_NOT_FOUND);
menu_entries_append_enum(info->list, str, "",
MENU_ENUM_LABEL_VALUE_DIRECTORY_NOT_FOUND, 0, 0, 0);
goto end;
}
dir_list_sort(str_list, true);
list_size = str_list->size;
if (list_size == 0)
{
string_list_free(str_list);
str_list = NULL;
}
else
{
for (i = 0; i < list_size; i++)
{
char label[PATH_MAX_LENGTH];
bool is_dir = false;
enum msg_hash_enums enum_idx = MSG_UNKNOWN;
enum msg_file_type file_type = FILE_TYPE_NONE;
const char *path = str_list->elems[i].data;
label[0] = '\0';
switch (str_list->elems[i].attr.i)
{
case RARCH_DIRECTORY:
file_type = FILE_TYPE_DIRECTORY;
break;
case RARCH_COMPRESSED_ARCHIVE:
file_type = FILE_TYPE_CARCHIVE;
break;
case RARCH_COMPRESSED_FILE_IN_ARCHIVE:
file_type = FILE_TYPE_IN_CARCHIVE;
break;
case RARCH_PLAIN_FILE:
default:
file_type = (enum msg_file_type)info->type_default;
switch (type)
{
/* in case of deferred_core_list we have to interpret
* every archive as an archive to disallow instant loading
*/
case DISPLAYLIST_CORES_DETECTED:
if (path_is_compressed_file(path))
file_type = FILE_TYPE_CARCHIVE;
break;
default:
break;
}
break;
}
is_dir = (file_type == FILE_TYPE_DIRECTORY);
if (!is_dir)
{
if (filebrowser_types == FILEBROWSER_SELECT_DIR)
continue;
if (filebrowser_types == FILEBROWSER_SCAN_DIR)
continue;
}
/* Need to preserve slash first time. */
if (!string_is_empty(info->path) && !path_is_compressed)
path = path_basename(path);
if (filebrowser_types == FILEBROWSER_SELECT_COLLECTION)
{
if (is_dir)
file_type = FILE_TYPE_DIRECTORY;
else
file_type = FILE_TYPE_PLAYLIST_COLLECTION;
}
if (!is_dir &&
(settings->multimedia.builtin_mediaplayer_enable ||
settings->multimedia.builtin_imageviewer_enable))
{
switch (path_is_media_type(path))
{
case RARCH_CONTENT_MOVIE:
#ifdef HAVE_FFMPEG
if (settings->multimedia.builtin_mediaplayer_enable)
file_type = FILE_TYPE_MOVIE;
#endif
break;
case RARCH_CONTENT_MUSIC:
#ifdef HAVE_FFMPEG
if (settings->multimedia.builtin_mediaplayer_enable)
file_type = FILE_TYPE_MUSIC;
#endif
break;
case RARCH_CONTENT_IMAGE:
#ifdef HAVE_IMAGEVIEWER
if (settings->multimedia.builtin_imageviewer_enable
&& type != DISPLAYLIST_IMAGES)
file_type = FILE_TYPE_IMAGEVIEWER;
else
file_type = FILE_TYPE_IMAGE;
#endif
break;
default:
break;
}
}
switch (file_type)
{
case FILE_TYPE_PLAIN:
#if 0
enum_idx = MENU_ENUM_LABEL_FILE_BROWSER_PLAIN_FILE;
#endif
files_count++;
break;
case FILE_TYPE_MOVIE:
enum_idx = MENU_ENUM_LABEL_FILE_BROWSER_MOVIE_OPEN;
files_count++;
break;
case FILE_TYPE_MUSIC:
enum_idx = MENU_ENUM_LABEL_FILE_BROWSER_MUSIC_OPEN;
files_count++;
break;
case FILE_TYPE_IMAGE:
enum_idx = MENU_ENUM_LABEL_FILE_BROWSER_IMAGE;
files_count++;
break;
case FILE_TYPE_IMAGEVIEWER:
enum_idx = MENU_ENUM_LABEL_FILE_BROWSER_IMAGE_OPEN_WITH_VIEWER;
files_count++;
break;
case FILE_TYPE_DIRECTORY:
enum_idx = MENU_ENUM_LABEL_FILE_BROWSER_DIRECTORY;
dirs_count++;
break;
default:
break;
}
items_found++;
menu_entries_append_enum(info->list, path, label,
enum_idx,
file_type, 0, 0);
}
}
if (str_list && str_list->size > 0)
string_list_free(str_list);
if (items_found == 0)
{
menu_entries_append_enum(info->list,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NO_ITEMS),
msg_hash_to_str(MENU_ENUM_LABEL_NO_ITEMS),
MENU_ENUM_LABEL_NO_ITEMS,
MENU_SETTING_NO_ITEM, 0, 0);
}
/* We don't want to show 'filter by extension' for this. */
if (filebrowser_types == FILEBROWSER_SELECT_DIR)
goto end;
if (filebrowser_types == FILEBROWSER_SCAN_DIR)
goto end;
if (!extensions_honored && files_count > 0)
menu_entries_prepend(info->list,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NAVIGATION_BROWSER_FILTER_SUPPORTED_EXTENSIONS_ENABLE),
msg_hash_to_str(MENU_ENUM_LABEL_NAVIGATION_BROWSER_FILTER_SUPPORTED_EXTENSIONS_ENABLE),
MENU_ENUM_LABEL_NAVIGATION_BROWSER_FILTER_SUPPORTED_EXTENSIONS_ENABLE,
0, 0 ,0);
end:
menu_entries_prepend(info->list,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_PARENT_DIRECTORY),
info->path,
MENU_ENUM_LABEL_PARENT_DIRECTORY,
FILE_TYPE_PARENT_DIRECTORY, 0, 0);
}
