INT_PTR CALLBACK PickCoreProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) { size_t list_size; core_info_list_t *core_info_list = NULL; const core_info_t *core_info = NULL; switch (message) { case WM_INITDIALOG: { HWND hwndList; unsigned i; /* Add items to list. */ core_info_get_list(&core_info_list); core_info_list_get_supported_cores(core_info_list, path_get(RARCH_PATH_CONTENT), &core_info, &list_size); hwndList = GetDlgItem(hDlg, ID_CORELISTBOX); for (i = 0; i < list_size; i++) { const core_info_t *info = (const core_info_t*)&core_info[i]; SendMessage(hwndList, LB_ADDSTRING, 0, (LPARAM)info->display_name); } SetFocus(hwndList); return TRUE; } case WM_COMMAND: switch (LOWORD(wParam)) { case IDOK: case IDCANCEL: EndDialog(hDlg, LOWORD(wParam)); break; case ID_CORELISTBOX: switch (HIWORD(wParam)) { case LBN_SELCHANGE: { int lbItem; const core_info_t *info = NULL; HWND hwndList = GetDlgItem(hDlg, ID_CORELISTBOX); lbItem = (int)SendMessage(hwndList, LB_GETCURSEL, 0, 0); core_info_get_list(&core_info_list); core_info_list_get_supported_cores(core_info_list, path_get(RARCH_PATH_CONTENT), &core_info, &list_size); info = (const core_info_t*)&core_info[lbItem]; runloop_ctl(RUNLOOP_CTL_SET_LIBRETRO_PATH,info->path); } break; } return TRUE; } } return FALSE; }
database_info_handle_t *database_info_dir_init(const char *dir, enum database_type type, retro_task_t *task, bool show_hidden_files) { core_info_list_t *core_info_list = NULL; struct string_list *list = NULL; database_info_handle_t *db = (database_info_handle_t*) calloc(1, sizeof(*db)); if (!db) return NULL; core_info_get_list(&core_info_list); list = dir_list_new(dir, core_info_list->all_ext, false, show_hidden_files, false, true); if (!list) { free(db); return NULL; } dir_list_prioritize(list); db->list = list; db->list_ptr = 0; db->status = DATABASE_STATUS_ITERATE; db->type = type; return db; }
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; }
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; }
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); }
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[PATH_MAX_LENGTH] = {0}; bool found_matching_core_association = false; settings_t *settings = config_get_ptr(); struct string_list *str_list = string_split(settings->playlist_names, ";"); struct string_list *str_list2 = string_split(settings->playlist_cores, ";"); strlcpy(s2, path, len2); *s = '\0'; *w = 19; strlcpy(playlist_name_with_ext, path, sizeof(playlist_name_with_ext)); strlcat(playlist_name_with_ext, ".lpl", 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 == NULL) 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, "DETECT") || !found_matching_core_association) strlcpy(s, "N/A", 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); }
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; }
struct string_list *dir_list_new_special(const char *input_dir, enum dir_list_type type, const char *filter) { char ext_shaders[PATH_MAX_LENGTH]; char ext_name[PATH_MAX_LENGTH]; const char *dir = NULL; const char *exts = NULL; bool include_dirs = false; settings_t *settings = config_get_ptr(); (void)input_dir; (void)settings; ext_shaders[0] = '\0'; switch (type) { case DIR_LIST_AUTOCONFIG: dir = input_dir; exts = filter; break; case DIR_LIST_CORES: dir = settings->directory.libretro; if (!frontend_driver_get_core_extension(ext_name, sizeof(ext_name))) return NULL; exts = ext_name; break; case DIR_LIST_CORE_INFO: { core_info_list_t *list = NULL; core_info_get_list(&list); dir = input_dir; exts = list->all_ext; } break; case DIR_LIST_SHADERS: dir = settings->directory.video_shader; #ifdef HAVE_CG strlcat(ext_shaders, "cg|cgp", sizeof(ext_shaders)); #endif #ifdef HAVE_GLSL strlcat(ext_shaders, "glsl|glslp", sizeof(ext_shaders)); #endif #ifdef HAVE_VULKAN strlcat(ext_shaders, "slang|slangp", sizeof(ext_shaders)); #endif exts = ext_shaders; break; case DIR_LIST_COLLECTIONS: dir = settings->directory.playlist; exts = "lpl"; break; case DIR_LIST_DATABASES: dir = settings->path.content_database; exts = "rdb"; break; case DIR_LIST_PLAIN: dir = input_dir; exts = filter; break; case DIR_LIST_NONE: default: return NULL; } return dir_list_new(dir, exts, include_dirs, type == DIR_LIST_CORE_INFO); }
struct string_list *string_list_new_special(enum string_list_type type, void *data, unsigned *len, size_t *list_size) { union string_list_elem_attr attr; unsigned i; core_info_list_t *core_info_list = NULL; const core_info_t *core_info = NULL; struct string_list *s = string_list_new(); if (!s || !len) goto error; attr.i = 0; *len = 0; switch (type) { case STRING_LIST_MENU_DRIVERS: #ifdef HAVE_MENU for (i = 0; menu_driver_find_handle(i); i++) { const char *opt = menu_driver_find_ident(i); *len += strlen(opt) + 1; string_list_append(s, opt, attr); } break; #endif case STRING_LIST_CAMERA_DRIVERS: #ifdef HAVE_CAMERA for (i = 0; camera_driver_find_handle(i); i++) { const char *opt = camera_driver_find_ident(i); *len += strlen(opt) + 1; string_list_append(s, opt, attr); } break; #endif case STRING_LIST_LOCATION_DRIVERS: #ifdef HAVE_LOCATION for (i = 0; location_driver_find_handle(i); i++) { const char *opt = location_driver_find_ident(i); *len += strlen(opt) + 1; string_list_append(options_l, opt, attr); } break; #endif case STRING_LIST_AUDIO_DRIVERS: for (i = 0; audio_driver_find_handle(i); i++) { const char *opt = audio_driver_find_ident(i); *len += strlen(opt) + 1; string_list_append(s, opt, attr); } break; case STRING_LIST_AUDIO_RESAMPLER_DRIVERS: for (i = 0; audio_resampler_driver_find_handle(i); i++) { const char *opt = audio_resampler_driver_find_ident(i); *len += strlen(opt) + 1; string_list_append(s, opt, attr); } break; case STRING_LIST_VIDEO_DRIVERS: for (i = 0; video_driver_find_handle(i); i++) { const char *opt = video_driver_find_ident(i); *len += strlen(opt) + 1; string_list_append(s, opt, attr); } break; case STRING_LIST_INPUT_DRIVERS: for (i = 0; input_driver_find_handle(i); i++) { const char *opt = input_driver_find_ident(i); *len += strlen(opt) + 1; string_list_append(s, opt, attr); } break; case STRING_LIST_INPUT_HID_DRIVERS: for (i = 0; hid_driver_find_handle(i); i++) { const char *opt = hid_driver_find_ident(i); *len += strlen(opt) + 1; string_list_append(s, opt, attr); } break; case STRING_LIST_INPUT_JOYPAD_DRIVERS: for (i = 0; joypad_driver_find_handle(i); i++) { const char *opt = joypad_driver_find_ident(i); *len += strlen(opt) + 1; string_list_append(s, opt, attr); } break; case STRING_LIST_RECORD_DRIVERS: for (i = 0; record_driver_find_handle(i); i++) { const char *opt = record_driver_find_ident(i); *len += strlen(opt) + 1; string_list_append(s, opt, attr); } break; case STRING_LIST_SUPPORTED_CORES_PATHS: core_info_get_list(&core_info_list); core_info_list_get_supported_cores(core_info_list, (const char*)data, &core_info, list_size); if (!core_info) goto error; if (*list_size == 0) goto error; for (i = 0; i < *list_size; i++) { const core_info_t *info = (const core_info_t*)&core_info[i]; const char *opt = info->path; if (!opt) goto error; *len += strlen(opt) + 1; string_list_append(s, opt, attr); } break; case STRING_LIST_SUPPORTED_CORES_NAMES: core_info_get_list(&core_info_list); core_info_list_get_supported_cores(core_info_list, (const char*)data, &core_info, list_size); if (!core_info) goto error; if (*list_size == 0) goto error; for (i = 0; i < *list_size; i++) { const char *opt = NULL; core_info_t *info = (core_info_t*)&core_info[i]; if (!info) goto error; opt = info->display_name; if (!opt) goto error; *len += strlen(opt) + 1; string_list_append(s, opt, attr); } break; case STRING_LIST_NONE: default: goto error; } return s; error: string_list_free(s); s = NULL; return NULL; }
/* Initialise runtime log, loading current parameters * if log file exists. Returned object must be free()'d. * Returns NULL if content_path and/or core_path are invalid */ runtime_log_t *runtime_log_init(const char *content_path, const char *core_path, bool log_per_core) { settings_t *settings = config_get_ptr(); core_info_list_t *core_info = NULL; runtime_log_t *runtime_log = NULL; const char *core_path_basename = path_basename(core_path); char content_name[PATH_MAX_LENGTH]; char core_name[PATH_MAX_LENGTH]; char log_file_dir[PATH_MAX_LENGTH]; char log_file_path[PATH_MAX_LENGTH]; char tmp_buf[PATH_MAX_LENGTH]; unsigned i; content_name[0] = '\0'; core_name[0] = '\0'; log_file_dir[0] = '\0'; log_file_path[0] = '\0'; tmp_buf[0] = '\0'; /* Error checking */ if (!settings) return NULL; if (string_is_empty(settings->paths.directory_playlist)) { RARCH_ERR("Playlist directory is undefined - cannot save runtime logs.\n"); return NULL; } if (string_is_empty(content_path) || string_is_empty(core_path_basename)) return NULL; if (string_is_equal(core_path, "builtin") || string_is_equal(core_path, file_path_str(FILE_PATH_DETECT))) return NULL; /* Get core name * Note: An annoyance - this is required even when * we are performing aggregate (not per core) logging, * since content name is sometimes dependent upon core * (e.g. see TyrQuake below) */ core_info_get_list(&core_info); if (!core_info) return NULL; for (i = 0; i < core_info->count; i++) { if (string_is_equal(path_basename(core_info->list[i].path), core_path_basename)) { strlcpy(core_name, core_info->list[i].core_name, sizeof(core_name)); break; } } if (string_is_empty(core_name)) return NULL; /* Get runtime log directory */ fill_pathname_join( tmp_buf, settings->paths.directory_playlist, "logs", sizeof(tmp_buf)); if (log_per_core) { fill_pathname_join( log_file_dir, tmp_buf, core_name, sizeof(log_file_dir)); } else { strlcpy(log_file_dir, tmp_buf, sizeof(log_file_dir)); } if (string_is_empty(log_file_dir)) return NULL; /* Create directory, if required */ if (!path_is_directory(log_file_dir)) { path_mkdir(log_file_dir); if(!path_is_directory(log_file_dir)) { RARCH_ERR("Failed to create directory for runtime log: %s.\n", log_file_dir); return NULL; } } /* Get content name * Note: TyrQuake requires a specific hack, since all * content has the same name... */ if (string_is_equal(core_name, "TyrQuake")) { const char *last_slash = find_last_slash(content_path); if (last_slash) { size_t path_length = last_slash + 1 - content_path; if (path_length < PATH_MAX_LENGTH) { memset(tmp_buf, 0, sizeof(tmp_buf)); strlcpy(tmp_buf, content_path, path_length * sizeof(char)); strlcpy(content_name, path_basename(tmp_buf), sizeof(content_name)); } } } else { /* path_remove_extension() requires a char * (not const) * so have to use a temporary buffer... */ tmp_buf[0] = '\0'; strlcpy(tmp_buf, path_basename(content_path), sizeof(tmp_buf)); strlcpy(content_name, path_remove_extension(tmp_buf), sizeof(content_name)); } if (string_is_empty(content_name)) return NULL; /* Build final log file path */ fill_pathname_join(log_file_path, log_file_dir, content_name, sizeof(log_file_path)); strlcat(log_file_path, file_path_str(FILE_PATH_RUNTIME_EXTENSION), sizeof(log_file_path)); if (string_is_empty(log_file_path)) return NULL; /* Phew... If we get this far then all is well. * > Create 'runtime_log' object */ runtime_log = (runtime_log_t*)calloc(1, sizeof(*runtime_log)); if (!runtime_log) return NULL; /* > Populate default values */ runtime_log->runtime.hours = 0; runtime_log->runtime.minutes = 0; runtime_log->runtime.seconds = 0; runtime_log->last_played.year = 0; runtime_log->last_played.month = 0; runtime_log->last_played.day = 0; runtime_log->last_played.hour = 0; runtime_log->last_played.minute = 0; runtime_log->last_played.second = 0; strlcpy(runtime_log->path, log_file_path, sizeof(runtime_log->path)); /* Load existing log file, if it exists */ runtime_log_read_file(runtime_log); return runtime_log; }
static int general_push(menu_displaylist_info_t *info, unsigned id, enum menu_displaylist_ctl_state state) { struct retro_system_info *system_menu = NULL; settings_t *settings = config_get_ptr(); rarch_system_info_t *system = NULL; core_info_list_t *list = NULL; menu_handle_t *menu = NULL; if (!menu_driver_ctl(RARCH_MENU_CTL_DRIVER_DATA_GET, &menu)) return menu_cbs_exit(); core_info_get_list(&list); menu_driver_ctl(RARCH_MENU_CTL_SYSTEM_INFO_GET, &system_menu); runloop_ctl(RUNLOOP_CTL_SYSTEM_INFO_GET, &system); switch (id) { case PUSH_DEFAULT: case PUSH_DETECT_CORE_LIST: break; default: fill_pathname_join(info->path, menu->scratch2_buf, menu->scratch_buf, sizeof(info->path)); fill_pathname_join(info->label, menu->scratch2_buf, menu->scratch_buf, sizeof(info->label)); break; } info->type_default = MENU_FILE_PLAIN; switch (id) { case PUSH_ARCHIVE_OPEN_DETECT_CORE: case PUSH_ARCHIVE_OPEN: case PUSH_DEFAULT: info->setting = menu_setting_find(info->label); break; default: break; } switch (id) { case PUSH_ARCHIVE_OPEN_DETECT_CORE: if (!string_is_empty(list->all_ext)) strlcpy(info->exts, list->all_ext, sizeof(info->exts)); else if (system_menu->valid_extensions) { if (*system_menu->valid_extensions) strlcpy(info->exts, system_menu->valid_extensions, sizeof(info->exts)); } else strlcpy(info->exts, system->valid_extensions, sizeof(info->exts)); break; case PUSH_ARCHIVE_OPEN: if (system_menu->valid_extensions) { if (*system_menu->valid_extensions) strlcpy(info->exts, system_menu->valid_extensions, sizeof(info->exts)); } else strlcpy(info->exts, system->valid_extensions, sizeof(info->exts)); break; case PUSH_DEFAULT: if (menu_setting_get_browser_selection_type(info->setting) == ST_DIR) { } else if (system_menu->valid_extensions) { if (*system_menu->valid_extensions) strlcpy(info->exts, system_menu->valid_extensions, sizeof(info->exts)); } else { if (!string_is_empty(system->valid_extensions)) strlcpy(info->exts, system->valid_extensions, sizeof(info->exts)); } break; case PUSH_DETECT_CORE_LIST: if (!string_is_empty(list->all_ext)) strlcpy(info->exts, list->all_ext, sizeof(info->exts)); break; } (void)settings; if (settings->multimedia.builtin_mediaplayer_enable || settings->multimedia.builtin_imageviewer_enable) { struct retro_system_info sysinfo = {0}; (void)sysinfo; #ifdef HAVE_FFMPEG if (settings->multimedia.builtin_mediaplayer_enable) { libretro_ffmpeg_retro_get_system_info(&sysinfo); strlcat(info->exts, "|", sizeof(info->exts)); strlcat(info->exts, sysinfo.valid_extensions, sizeof(info->exts)); } #endif #ifdef HAVE_IMAGEVIEWER if (settings->multimedia.builtin_imageviewer_enable) { libretro_imageviewer_retro_get_system_info(&sysinfo); strlcat(info->exts, "|", sizeof(info->exts)); strlcat(info->exts, sysinfo.valid_extensions, sizeof(info->exts)); } #endif } return deferred_push_dlist(info, state); }
/* 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 LoadCoreWindow::initCoreList(const QStringList &extensionFilters) { core_info_list_t *cores = NULL; QStringList horizontal_header_labels; QDesktopWidget *desktop = qApp->desktop(); QRect desktopRect = desktop->availableGeometry(); unsigned i = 0; int j = 0; horizontal_header_labels << msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_NAME); horizontal_header_labels << msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_CORE_VERSION); core_info_get_list(&cores); m_table->clear(); m_table->setColumnCount(0); m_table->setRowCount(0); m_table->setSelectionBehavior(QAbstractItemView::SelectRows); m_table->setSelectionMode(QAbstractItemView::SingleSelection); m_table->setSortingEnabled(false); m_table->setRowCount(cores->count); m_table->setColumnCount(2); m_table->setHorizontalHeaderLabels(horizontal_header_labels); for (i = 0; i < cores->count; i++) { core_info_t *core = core_info_get(cores, i); QTableWidgetItem *name_item = NULL; QTableWidgetItem *version_item = new QTableWidgetItem(core->display_version); QVariantHash hash; const char *name = core->display_name; if (string_is_empty(name)) name = path_basename(core->path); name_item = new QTableWidgetItem(name); hash["path"] = core->path; hash["extensions"] = QString(core->supported_extensions).split("|"); name_item->setData(Qt::UserRole, hash); name_item->setFlags(name_item->flags() & ~Qt::ItemIsEditable); version_item->setFlags(version_item->flags() & ~Qt::ItemIsEditable); m_table->setItem(i, CORE_NAME_COLUMN, name_item); m_table->setItem(i, CORE_VERSION_COLUMN, version_item); } if (!extensionFilters.isEmpty()) { QVector<int> rowsToHide; for (j = 0; j < m_table->rowCount(); j++) { bool found = false; QTableWidgetItem *item = m_table->item(j, CORE_NAME_COLUMN); QVariantHash hash; QStringList extensions; int k = 0; if (!item) continue; hash = item->data(Qt::UserRole).toHash(); extensions = hash["extensions"].toStringList(); if (!extensions.isEmpty()) { for (k = 0; k < extensions.size(); k++) { QString ext = extensions.at(k).toLower(); if (extensionFilters.contains(ext, Qt::CaseInsensitive)) { found = true; break; } } if (!found) rowsToHide.append(j); } } if (rowsToHide.size() != m_table->rowCount()) { foreach (const int &row, rowsToHide) { m_table->setRowHidden(row, true); }
void MainWindow::onPlaylistWidgetContextMenuRequested(const QPoint&) { settings_t *settings = config_get_ptr(); QScopedPointer<QMenu> menu; QScopedPointer<QMenu> associateMenu; QScopedPointer<QMenu> hiddenPlaylistsMenu; QScopedPointer<QAction> hideAction; QScopedPointer<QAction> newPlaylistAction; QScopedPointer<QAction> deletePlaylistAction; QPointer<QAction> selectedAction; QPoint cursorPos = QCursor::pos(); QListWidgetItem *selectedItem = m_listWidget->itemAt(m_listWidget->viewport()->mapFromGlobal(cursorPos)); QDir playlistDir(settings->paths.directory_playlist); QString playlistDirAbsPath = playlistDir.absolutePath(); QString currentPlaylistDirPath; QString currentPlaylistPath; QString currentPlaylistFileName; QFile currentPlaylistFile; QByteArray currentPlaylistFileNameArray; QFileInfo currentPlaylistFileInfo; QMap<QString, const core_info_t*> coreList; core_info_list_t *core_info_list = NULL; union string_list_elem_attr attr = {0}; struct string_list *stnames = NULL; struct string_list *stcores = NULL; unsigned i = 0; int j = 0; size_t found = 0; const char *currentPlaylistFileNameData = NULL; char new_playlist_names[PATH_MAX_LENGTH]; char new_playlist_cores[PATH_MAX_LENGTH]; bool specialPlaylist = false; bool foundHiddenPlaylist = false; new_playlist_names[0] = new_playlist_cores[0] = '\0'; stnames = string_split(settings->arrays.playlist_names, ";"); stcores = string_split(settings->arrays.playlist_cores, ";"); if (selectedItem) { currentPlaylistPath = selectedItem->data(Qt::UserRole).toString(); currentPlaylistFile.setFileName(currentPlaylistPath); currentPlaylistFileInfo = QFileInfo(currentPlaylistPath); currentPlaylistFileName = currentPlaylistFileInfo.fileName(); currentPlaylistDirPath = currentPlaylistFileInfo.absoluteDir().absolutePath(); currentPlaylistFileNameArray.append(currentPlaylistFileName); currentPlaylistFileNameData = currentPlaylistFileNameArray.constData(); } menu.reset(new QMenu(this)); menu->setObjectName("menu"); hiddenPlaylistsMenu.reset(new QMenu(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_HIDDEN_PLAYLISTS), this)); newPlaylistAction.reset(new QAction(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_NEW_PLAYLIST)) + "...", this)); hiddenPlaylistsMenu->setObjectName("hiddenPlaylistsMenu"); menu->addAction(newPlaylistAction.data()); if (currentPlaylistFile.exists()) { deletePlaylistAction.reset(new QAction(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_DELETE_PLAYLIST)) + "...", this)); menu->addAction(deletePlaylistAction.data()); } if (selectedItem) { hideAction.reset(new QAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_HIDE), this)); menu->addAction(hideAction.data()); } for (j = 0; j < m_listWidget->count(); j++) { QListWidgetItem *item = m_listWidget->item(j); bool hidden = m_listWidget->isItemHidden(item); if (hidden) { QAction *action = hiddenPlaylistsMenu->addAction(item->text()); action->setProperty("row", j); action->setProperty("core_path", item->data(Qt::UserRole).toString()); foundHiddenPlaylist = true; } } if (!foundHiddenPlaylist) { QAction *action = hiddenPlaylistsMenu->addAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NONE)); action->setProperty("row", -1); } menu->addMenu(hiddenPlaylistsMenu.data()); if (currentPlaylistDirPath != playlistDirAbsPath) { /* special playlists like history etc. can't have an association */ specialPlaylist = true; } if (!specialPlaylist) { associateMenu.reset(new QMenu(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_ASSOCIATE_CORE), this)); associateMenu->setObjectName("associateMenu"); core_info_get_list(&core_info_list); for (i = 0; i < core_info_list->count && core_info_list->count > 0; i++) { const core_info_t *core = &core_info_list->list[i]; coreList[core->core_name] = core; } { QMapIterator<QString, const core_info_t*> coreListIterator(coreList); QVector<QHash<QString, QString> > cores; while (coreListIterator.hasNext()) { QString key; const core_info_t *core = NULL; QString name; QHash<QString, QString> hash; coreListIterator.next(); key = coreListIterator.key(); core = coreList.value(key); if (string_is_empty(core->core_name)) name = core->display_name; else name = core->core_name; if (name.isEmpty()) continue; hash["name"] = name; hash["core_path"] = core->path; cores.append(hash); } std::sort(cores.begin(), cores.end(), comp_hash_name_key_lower); for (j = 0; j < cores.count(); j++) { const QHash<QString, QString> &hash = cores.at(j); QAction *action = associateMenu->addAction(hash.value("name")); action->setProperty("core_path", hash.value("core_path")); } } menu->addMenu(associateMenu.data()); } selectedAction = menu->exec(cursorPos); if (!selectedAction) goto end; if (!specialPlaylist && selectedAction->parent() == associateMenu.data()) { found = string_list_find_elem(stnames, currentPlaylistFileNameData); if (found) string_list_set(stcores, static_cast<unsigned>(found - 1), selectedAction->property("core_path").toString().toUtf8().constData()); else { string_list_append(stnames, currentPlaylistFileNameData, attr); string_list_append(stcores, "DETECT", attr); found = string_list_find_elem(stnames, currentPlaylistFileNameData); if (found) string_list_set(stcores, static_cast<unsigned>(found - 1), selectedAction->property("core_path").toString().toUtf8().constData()); } string_list_join_concat(new_playlist_names, sizeof(new_playlist_names), stnames, ";"); string_list_join_concat(new_playlist_cores, sizeof(new_playlist_cores), stcores, ";"); strlcpy(settings->arrays.playlist_names, new_playlist_names, sizeof(settings->arrays.playlist_names)); strlcpy(settings->arrays.playlist_cores, new_playlist_cores, sizeof(settings->arrays.playlist_cores)); } else if (selectedItem && selectedAction == deletePlaylistAction.data()) { if (currentPlaylistFile.exists()) { if (showMessageBox(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_CONFIRM_DELETE_PLAYLIST)).arg(selectedItem->text()), MainWindow::MSGBOX_TYPE_QUESTION_YESNO, Qt::ApplicationModal, false)) { if (currentPlaylistFile.remove()) reloadPlaylists(); else showMessageBox(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_COULD_NOT_DELETE_FILE), MainWindow::MSGBOX_TYPE_ERROR, Qt::ApplicationModal, false); } } } else if (selectedAction == newPlaylistAction.data()) { QString name = QInputDialog::getText(this, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_NEW_PLAYLIST), msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_ENTER_NEW_PLAYLIST_NAME)); QString newPlaylistPath = playlistDirAbsPath + "/" + name + file_path_str(FILE_PATH_LPL_EXTENSION); QFile file(newPlaylistPath); if (file.open(QIODevice::WriteOnly)) file.close(); reloadPlaylists(); } else if (selectedItem && selectedAction == hideAction.data()) { int row = m_listWidget->row(selectedItem); if (row >= 0) { QStringList hiddenPlaylists = m_settings->value("hidden_playlists").toStringList(); if (!hiddenPlaylists.contains(currentPlaylistFileName)) { hiddenPlaylists.append(currentPlaylistFileName); m_settings->setValue("hidden_playlists", hiddenPlaylists); } m_listWidget->setRowHidden(row, true); } } else if (selectedAction->parent() == hiddenPlaylistsMenu.data()) { QVariant rowVariant = selectedAction->property("row"); if (rowVariant.isValid()) { QStringList hiddenPlaylists = m_settings->value("hidden_playlists").toStringList(); int row = rowVariant.toInt(); if (row >= 0) { QString playlistPath = selectedAction->property("core_path").toString(); QFileInfo playlistFileInfo(playlistPath); QString playlistFileName = playlistFileInfo.fileName(); if (hiddenPlaylists.contains(playlistFileName)) { hiddenPlaylists.removeOne(playlistFileName); m_settings->setValue("hidden_playlists", hiddenPlaylists); } m_listWidget->setRowHidden(row, false); } } } setCoreActions(); end: if (stnames) string_list_free(stnames); if (stcores) string_list_free(stcores); }
struct string_list *dir_list_new_special(const char *input_dir, enum dir_list_type type, const char *filter) { char ext_shaders[PATH_MAX_LENGTH] = {0}; char ext_name[PATH_MAX_LENGTH] = {0}; const char *dir = NULL; const char *exts = NULL; bool include_dirs = false; (void)input_dir; switch (type) { case DIR_LIST_AUTOCONFIG: dir = input_dir; exts = filter; break; case DIR_LIST_CORES: dir = input_dir; if (!frontend_driver_get_core_extension(ext_name, sizeof(ext_name))) return NULL; exts = ext_name; break; case DIR_LIST_CORE_INFO: { core_info_list_t *list = NULL; core_info_get_list(&list); dir = input_dir; exts = list->all_ext; } break; case DIR_LIST_SHADERS: { union string_list_elem_attr attr = {0}; struct string_list *str_list = string_list_new(); if (!str_list) return NULL; dir = input_dir; #ifdef HAVE_CG string_list_append(str_list, "cg", attr); string_list_append(str_list, "cgp", attr); #endif #ifdef HAVE_GLSL string_list_append(str_list, "glsl", attr); string_list_append(str_list, "glslp", attr); #endif #ifdef HAVE_VULKAN string_list_append(str_list, "slang", attr); string_list_append(str_list, "slangp", attr); #endif string_list_join_concat(ext_shaders, sizeof(ext_shaders), str_list, "|"); string_list_free(str_list); exts = ext_shaders; } break; case DIR_LIST_COLLECTIONS: dir = input_dir; exts = "lpl"; break; case DIR_LIST_DATABASES: dir = input_dir; exts = "rdb"; break; case DIR_LIST_PLAIN: dir = input_dir; exts = filter; break; case DIR_LIST_NONE: default: return NULL; } return dir_list_new(dir, exts, include_dirs, type == DIR_LIST_CORE_INFO); }