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