static void task_push_content_update_firmware_status(
content_information_ctx_t *content_ctx)
{
char s[PATH_MAX_LENGTH];
core_info_ctx_firmware_t firmware_info;
core_info_t *core_info = NULL;
core_info_get_current_core(&core_info);
if (!core_info)
return;
firmware_info.path = core_info->path;
if (!string_is_empty(content_ctx->directory_system))
firmware_info.directory.system = content_ctx->directory_system;
else
{
strlcpy(s, path_get(RARCH_PATH_CONTENT) ,sizeof(s));
path_basedir_wrapper(s);
firmware_info.directory.system = s;
}
RARCH_LOG("Updating firmware status for: %s on %s\n", core_info->path,
firmware_info.directory.system);
core_info_list_update_missing_firmware(&firmware_info);
}
static void update_firmware_status(void)
{
char s[PATH_MAX_LENGTH];
core_info_ctx_firmware_t firmware_info;
core_info_t *core_info = NULL;
settings_t *settings = config_get_ptr();
core_info_get_current_core(&core_info);
if (!core_info || !settings)
return;
firmware_info.path = core_info->path;
if (!string_is_empty(settings->directory.system))
firmware_info.directory.system = settings->directory.system;
else
{
strlcpy(s, path_get(RARCH_PATH_CONTENT) ,sizeof(s));
path_basedir_wrapper(s);
firmware_info.directory.system = s;
}
RARCH_LOG("Updating firmware status for: %s on %s\n", core_info->path,
firmware_info.directory.system);
core_info_list_update_missing_firmware(&firmware_info);
}
bool core_info_load(core_info_ctx_find_t *info)
{
core_info_t *core_info = NULL;
if (!info)
return false;
core_info_get_current_core(&core_info);
if (!core_info_curr_list)
return false;
if (!core_info_list_get_info(core_info_curr_list,
core_info, info->path))
return false;
return true;
}
static int zarch_zui_render_lay_root_load(zui_t *zui,
struct zui_tabbed *tabbed)
{
char parent_dir[PATH_MAX_LENGTH];
settings_t *settings = config_get_ptr();
core_info_list_t *list = NULL;
parent_dir[0] = '\0';
if (zarch_zui_tab(zui, tabbed, "Load", 1))
{
unsigned cwd_offset;
if (!zui->load_cwd)
zui->load_cwd = strdup(settings->directory.menu_content);
if (!zui->load_dlist)
{
core_info_t *core_info = NULL;
core_info_get_current_core(&core_info);
zui->load_dlist = dir_list_new(zui->load_cwd,
core_info->supported_extensions, true, true, false, true);
dir_list_sort(zui->load_dlist, true);
zui->load_dlist_first = 0;
}
cwd_offset = MIN(strlen(zui->load_cwd), 60);
zarch_zui_draw_text(zui, ZUI_FG_NORMAL, 15,
tabbed->tabline_size + 5 + 41,
&zui->load_cwd[strlen(zui->load_cwd) - cwd_offset]);
if (zarch_zui_button(zui, zui->width - 290 - 129,
tabbed->tabline_size + 5, "Home"))
zarch_zui_render_lay_root_load_free(zui);
if (zui->load_dlist)
{
fill_pathname_parent_dir(parent_dir,
zui->load_cwd, sizeof(parent_dir));
if (!string_is_empty(parent_dir) &&
zarch_zui_list_item(zui, tabbed, 0,
tabbed->tabline_size + 73, " ..", 0, NULL, false /* TODO/FIXME */))
{
zarch_zui_render_lay_root_load_set_new_path(zui, parent_dir);
}
else
{
static int gamepad_index = 0;
unsigned size = zui->load_dlist->size;
unsigned i, j = 1;
unsigned skip = 0;
for (i = 0; i < size; ++i)
{
const char *basename =
path_basename(zui->load_dlist->elems[i].data);
if (basename[0] != '.')
break;
skip++;
}
if (zarch_zui_gamepad_input(zui, &gamepad_index,
&zui->load_dlist_first, skip))
zui->load_dlist_first = gamepad_index;
for (i = skip + zui->load_dlist_first; i < size; ++i)
{
char label[PATH_MAX_LENGTH];
const char *path = NULL;
const char *basename = NULL;
if (j > 10)
break;
label[0] = '\0';
path = zui->load_dlist->elems[i].data;
basename = path_basename(path);
*label = 0;
strncat(label, " ", sizeof(label)-1);
strncat(label, basename, sizeof(label)-1);
if (path_is_directory(path))
strncat(label, "/", sizeof(label)-1);
if (zarch_zui_list_item(zui, tabbed, 0,
tabbed->tabline_size + 73 + j * ZUI_ITEM_SIZE_PX,
label, i, NULL, gamepad_index == (signed)(i-skip)))
{
if (path_is_directory(path))
{
zarch_zui_render_lay_root_load_set_new_path(zui, path);
break;
}
zui->pick_cores = NULL;
zui->pick_supported = 0;
strlcpy(zui->pick_content,
path, sizeof(zui->pick_content));
core_info_get_list(&list);
core_info_list_get_supported_cores(list, path,
&zui->pick_cores, &zui->pick_supported);
zarch_layout = LAY_PICK_CORE;
break;
}
j++;
}
}
}
}
else if (zui->load_dlist)
{
dir_list_free(zui->load_dlist);
zui->load_dlist = NULL;
}
return 0;
}
/**
* menu_content_find_first_core:
* @core_info : Core info list handle.
* @dir : Directory. Gets joined with @path.
* @path : Path. Gets joined with @dir.
* @menu_label : Label identifier of menu setting.
* @s : Deferred core path. Will be filled in
* by function.
* @len : Size of @s.
*
* Gets deferred core.
*
* Returns: false if there are multiple deferred cores and a
* selection needs to be made from a list, otherwise
* returns true and fills in @s with path to core.
**/
bool menu_content_find_first_core(menu_content_ctx_defer_info_t *def_info,
bool load_content_with_current_core,
char *new_core_path, size_t len)
{
const core_info_t *info = NULL;
core_info_list_t *core_info = NULL;
const char *default_info_dir = NULL;
size_t supported = 0;
if (def_info)
{
core_info = (core_info_list_t*)def_info->data;
default_info_dir = def_info->dir;
}
if (!string_is_empty(default_info_dir))
{
const char *default_info_path = NULL;
size_t default_info_length = 0;
if (def_info)
{
default_info_path = def_info->path;
default_info_length = def_info->len;
}
if (!string_is_empty(default_info_path))
fill_pathname_join(def_info->s,
default_info_dir, default_info_path,
default_info_length);
#ifdef HAVE_COMPRESSION
if (path_is_compressed_file(default_info_dir))
{
size_t len = strlen(default_info_dir);
/* In case of a compressed archive, we have to join with a hash */
/* We are going to write at the position of dir: */
retro_assert(len < strlen(def_info->s));
def_info->s[len] = '#';
}
#endif
}
if (core_info)
core_info_list_get_supported_cores(core_info,
def_info->s, &info,
&supported);
/* We started the menu with 'Load Content', we are
* going to use the current core to load this. */
if (load_content_with_current_core)
{
core_info_get_current_core((core_info_t**)&info);
if (info)
{
RARCH_LOG("Use the current core (%s) to load this content...\n",
info->path);
supported = 1;
}
}
/* There are multiple deferred cores and a
* selection needs to be made from a list, return 0. */
if (supported != 1)
return false;
if (info)
strlcpy(new_core_path, info->path, len);
return true;
}
/* Get the count of the files dropped */
static int win32_drag_query_file(HWND hwnd, WPARAM wparam)
{
char szFilename[1024];
szFilename[0] = '\0';
if (DragQueryFile((HDROP)wparam, 0xFFFFFFFF, NULL, 0))
{
/*poll list of current cores */
size_t list_size;
content_ctx_info_t content_info = {0};
core_info_list_t *core_info_list = NULL;
const core_info_t *core_info = NULL;
DragQueryFile((HDROP)wparam, 0, szFilename, sizeof(szFilename));
core_info_get_list(&core_info_list);
if (!core_info_list)
return 0;
core_info_list_get_supported_cores(core_info_list,
(const char*)szFilename, &core_info, &list_size);
if (!list_size)
return 0;
path_set(RARCH_PATH_CONTENT, szFilename);
if (!path_is_empty(RARCH_PATH_CONTENT))
{
unsigned i;
core_info_t *current_core = NULL;
core_info_get_current_core(¤t_core);
/*we already have path for libretro core */
for (i = 0; i < list_size; i++)
{
const core_info_t *info = (const core_info_t*)&core_info[i];
if(!string_is_equal(info->systemname, current_core->systemname))
break;
if(string_is_equal(path_get(RARCH_PATH_CORE), info->path))
{
/* Our previous core supports the current rom */
content_ctx_info_t content_info = {0};
task_push_content_load_default(
NULL, NULL,
&content_info,
CORE_TYPE_PLAIN,
CONTENT_MODE_LOAD_CONTENT_WITH_CURRENT_CORE_FROM_COMPANION_UI,
NULL, NULL);
return 0;
}
}
}
/* Poll for cores for current rom since none exist. */
if(list_size ==1)
{
/*pick core that only exists and is bound to work. Ish. */
const core_info_t *info = (const core_info_t*)&core_info[0];
if (info)
task_push_content_load_default(
info->path, NULL,
&content_info,
CORE_TYPE_PLAIN,
CONTENT_MODE_LOAD_CONTENT_WITH_NEW_CORE_FROM_COMPANION_UI,
NULL, NULL);
}
else
{
/* Pick one core that could be compatible, ew */
if(DialogBoxParam(GetModuleHandle(NULL),MAKEINTRESOURCE(IDD_PICKCORE),
hwnd,PickCoreProc,(LPARAM)NULL)==IDOK)
{
task_push_content_load_default(
NULL, NULL,
&content_info,
CORE_TYPE_PLAIN,
CONTENT_MODE_LOAD_CONTENT_WITH_CURRENT_CORE_FROM_COMPANION_UI,
NULL, NULL);
}
}
}
return 0;
}
void discord_update(enum discord_presence presence)
{
core_info_t *core_info = NULL;
core_info_get_current_core(&core_info);
if (!discord_ready)
return;
if (presence == discord_status)
return;
if (presence == DISCORD_PRESENCE_NONE || presence == DISCORD_PRESENCE_MENU)
memset(&discord_presence, 0, sizeof(discord_presence));
switch (presence)
{
case DISCORD_PRESENCE_MENU:
discord_presence.details = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_DISCORD_IN_MENU);
discord_presence.largeImageKey = "base";
discord_presence.largeImageText = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NO_CORE);
discord_presence.instance = 0;
break;
case DISCORD_PRESENCE_GAME_PAUSED:
discord_presence.smallImageKey = "paused";
discord_presence.smallImageText = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_DISCORD_STATUS_PAUSED);
discord_presence.details = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_DISCORD_IN_GAME_PAUSED);
pause_time = time(0);
ellapsed_time = difftime(time(0), start_time);
discord_presence.startTimestamp = pause_time;
break;
case DISCORD_PRESENCE_GAME:
if (core_info)
{
const char *system_id = core_info->system_id ? core_info->system_id : "core";
char *label = NULL;
playlist_t *current_playlist = playlist_get_cached();
if (current_playlist)
playlist_get_index_by_path(
current_playlist, path_get(RARCH_PATH_CONTENT), NULL, &label, NULL, NULL, NULL, NULL);
if (!label)
label = (char *)path_basename(path_get(RARCH_PATH_BASENAME));
#if 0
RARCH_LOG("[Discord] current core: %s\n", system_id);
RARCH_LOG("[Discord] current content: %s\n", label);
#endif
discord_presence.largeImageKey = system_id;
if (core_info->display_name)
discord_presence.largeImageText = core_info->display_name;
start_time = time(0);
if (pause_time != 0)
start_time = time(0) - ellapsed_time;
pause_time = 0;
ellapsed_time = 0;
discord_presence.smallImageKey = "playing";
discord_presence.smallImageText = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_DISCORD_STATUS_PLAYING);
discord_presence.startTimestamp = start_time;
discord_presence.details = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_DISCORD_IN_GAME);
discord_presence.state = label;
discord_presence.instance = 0;
}
break;
case DISCORD_PRESENCE_NETPLAY_HOSTING:
room = netplay_get_host_room();
if (room->id == 0)
return;
RARCH_LOG("[Discord] netplay room details: id=%d, nick=%s IP=%s port=%d\n",
room->id, room->nickname,
room->host_method == NETPLAY_HOST_METHOD_MITM ? room->mitm_address : room->address,
room->host_method == NETPLAY_HOST_METHOD_MITM ? room->mitm_port : room->port);
char party_id[128];
snprintf(party_id, sizeof(party_id), "%d|%s", room->id, room->nickname);
char join_secret[128];
snprintf(join_secret, sizeof(join_secret), "%s|%d|%s|%u|%s",
room->host_method == NETPLAY_HOST_METHOD_MITM ? room->mitm_address : room->address,
room->host_method == NETPLAY_HOST_METHOD_MITM ? room->mitm_port : room->port,
room->gamename, room->gamecrc, room->corename);
RARCH_LOG("%s\n", join_secret);
discord_presence.joinSecret = strdup(join_secret);
discord_presence.spectateSecret = "SPECSPECSPEC";
discord_presence.partyId = party_id;
discord_presence.partyMax = 0;
discord_presence.partySize = 0;
break;
case DISCORD_PRESENCE_NETPLAY_HOSTING_STOPPED:
case DISCORD_PRESENCE_NETPLAY_CLIENT:
default:
discord_presence.joinSecret = NULL;
break;
}
RARCH_LOG("[Discord] updating (%d)\n", presence);
Discord_UpdatePresence(&discord_presence);
discord_status = presence;
}
