static int action_start_shader_action_preset_parameter(unsigned type, const char *label, unsigned action) { #ifdef HAVE_SHADER_MANAGER struct video_shader *shader = NULL; struct video_shader_parameter *param = NULL; menu_handle_t *menu = menu_driver_get_ptr(); if (!menu) return -1; if (!(shader = menu->shader)) return 0; param = &shader->parameters[type - MENU_SETTINGS_SHADER_PRESET_PARAMETER_0]; param->current = param->initial; param->current = min(max(param->minimum, param->current), param->maximum); #endif return 0; }
static int action_start_shader_num_passes(unsigned type, const char *label, unsigned action) { #ifdef HAVE_SHADER_MANAGER struct video_shader *shader = NULL; menu_handle_t *menu = menu_driver_get_ptr(); if (!menu) return -1; shader = menu->shader; if (!shader) return -1; if (shader->passes) shader->passes = 0; menu->need_refresh = true; video_shader_resolve_parameters(NULL, menu->shader); #endif return 0; }
static int action_ok_rdb_entry(const char *path, const char *label, unsigned type, size_t idx) { char tmp[PATH_MAX_LENGTH]; menu_displaylist_info_t info = {0}; menu_handle_t *menu = menu_driver_get_ptr(); if (!menu) return -1; strlcpy(tmp, "deferred_rdb_entry_detail|", sizeof(tmp)); strlcat(tmp, path, sizeof(tmp)); info.list = menu->menu_list->menu_stack; info.type = 0; info.directory_ptr = idx; strlcpy(info.path, label, sizeof(info.path)); strlcpy(info.label, tmp, sizeof(info.label)); return menu_displaylist_push_list(&info, DISPLAYLIST_GENERIC); }
static int action_ok_file_load_or_resume(const char *path, const char *label, unsigned type, size_t idx) { menu_handle_t *menu = menu_driver_get_ptr(); global_t *global = global_get_ptr(); if (!menu) return -1; if (!strcmp(menu->deferred_path, global->fullpath)) return generic_action_ok_command(EVENT_CMD_RESUME); else { strlcpy(global->fullpath, menu->deferred_path, sizeof(global->fullpath)); event_command(EVENT_CMD_LOAD_CORE); rarch_main_set_state(RARCH_ACTION_STATE_LOAD_CONTENT); return -1; } }
/** * menu_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). **/ bool menu_load_content(void) { menu_handle_t *menu = menu_driver_get_ptr(); driver_t *driver = driver_get_ptr(); global_t *global = global_get_ptr(); /* redraw menu frame */ if (menu) menu->msg_force = true; menu_entry_iterate(MENU_ACTION_NOOP); menu_display_fb(); if (!(main_load_content(0, NULL, NULL, menu_environment_get, driver->frontend_ctx->process_args))) { char name[PATH_MAX_LENGTH], msg[PATH_MAX_LENGTH]; fill_pathname_base(name, global->fullpath, sizeof(name)); snprintf(msg, sizeof(msg), "Failed to load %s.\n", name); rarch_main_msg_queue_push(msg, 1, 90, false); if (menu) menu->msg_force = true; return false; } menu_shader_manager_init(menu); event_command(EVENT_CMD_HISTORY_INIT); if (*global->fullpath || (menu && menu->load_no_content)) push_to_history_playlist(); event_command(EVENT_CMD_VIDEO_SET_ASPECT_RATIO); event_command(EVENT_CMD_RESUME); return true; }
static void menu_entries_build_scroll_indices(file_list_t *list) { size_t i; int current; bool current_is_dir; menu_navigation_t *nav = NULL; menu_handle_t *menu = menu_driver_get_ptr(); if (!menu || !list) return; nav = &menu->navigation; if (!nav) return; nav->scroll.indices.size = 0; if (!list->size) return; nav->scroll.indices.list[nav->scroll.indices.size++] = 0; current = menu_entries_list_get_first_char(list, 0); current_is_dir = menu_entries_list_elem_is_dir(list, 0); for (i = 1; i < list->size; i++) { int first = menu_entries_list_get_first_char(list, i); bool is_dir = menu_entries_list_elem_is_dir(list, i); if ((current_is_dir && !is_dir) || (first > current)) nav->scroll.indices.list[nav->scroll.indices.size++] = i; current = first; current_is_dir = is_dir; } nav->scroll.indices.list[nav->scroll.indices.size++] = list->size - 1; }
static void glui_render_messagebox(const char *message) { unsigned i; unsigned width, height; uint32_t normal_color; int x, y; struct string_list *list = NULL; menu_handle_t *menu = menu_driver_get_ptr(); menu_display_t *disp = menu_display_get_ptr(); settings_t *settings = config_get_ptr(); if (!menu || !disp || !menu->userdata) return; list = (struct string_list*)string_split(message, "\n"); if (!list) return; if (list->elems == 0) goto end; video_driver_get_size(&width, &height); x = width / 2; y = height / 2 - list->size * disp->font.size / 2; normal_color = FONT_COLOR_ARGB_TO_RGBA(settings->menu.entry_normal_color); for (i = 0; i < list->size; i++) { const char *msg = list->elems[i].data; if (msg) glui_blit_line(x, y + i * disp->font.size, width, height, msg, normal_color, TEXT_ALIGN_CENTER); } end: string_list_free(list); }
static void rmenu_set_texture(void) { unsigned fb_width, fb_height; menu_handle_t *menu = menu_driver_get_ptr(); if (!menu) return; if (menu_texture_inited) return; if (!menu_texture) return; if (!menu_texture->pixels) return; menu_display_ctl(MENU_DISPLAY_CTL_WIDTH, &fb_width); menu_display_ctl(MENU_DISPLAY_CTL_HEIGHT, &fb_height); video_driver_set_texture_frame(menu_texture->pixels, true, fb_width, fb_height, 1.0f); menu_texture_inited = true; }
static int action_ok_configurations_list(const char *path, const char *label, unsigned type, size_t idx) { menu_displaylist_info_t info = {0}; settings_t *settings = config_get_ptr(); menu_handle_t *menu = menu_driver_get_ptr(); const char *dir = settings->menu_config_directory; if (!menu) return -1; info.list = menu->menu_list->menu_stack; info.type = type; info.directory_ptr = idx; if (dir) strlcpy(info.path, dir, sizeof(info.path)); else strlcpy(info.path, label, sizeof(info.path)); strlcpy(info.label, label, sizeof(info.label)); return menu_displaylist_push_list(&info, DISPLAYLIST_GENERIC); }
static float glui_get_scroll(void) { int half = 0; unsigned width, height; glui_handle_t *glui = NULL; menu_handle_t *menu = menu_driver_get_ptr(); menu_navigation_t *nav = menu_navigation_get_ptr(); if (!menu || !menu->userdata) return 0; video_driver_get_size(&width, &height); glui = (glui_handle_t*)menu->userdata; if (glui->line_height) half = (height / glui->line_height) / 2; if (nav->selection_ptr < (unsigned)half) return 0; return ((nav->selection_ptr + 2 - half) * glui->line_height); }
static void rmenu_context_reset(void) { char menu_bg[PATH_MAX_LENGTH]; menu_handle_t *menu = menu_driver_get_ptr(); settings_t *settings = config_get_ptr(); if (!menu) return; if (*settings->menu.wallpaper) strlcpy(menu_bg, settings->menu.wallpaper, sizeof(menu_bg)); else rmenu_wallpaper_set_defaults(menu_bg, sizeof(menu_bg)); if (path_file_exists(menu_bg)) texture_image_load(menu_texture, menu_bg); menu->frame_buf.width = menu_texture->width; menu->frame_buf.height = menu_texture->height; menu_texture_inited = false; }
static int action_ok_disk_image_append(const char *path, const char *label, unsigned type, size_t idx) { char image[PATH_MAX_LENGTH]; const char *menu_path = NULL; menu_handle_t *menu = menu_driver_get_ptr(); if (!menu) return -1; menu_list_get_last_stack(menu->menu_list, &menu_path, NULL, NULL); fill_pathname_join(image, menu_path, path, sizeof(image)); event_disk_control_append_image(image); event_command(EVENT_CMD_RESUME); menu_list_flush_stack(menu->menu_list, MENU_SETTINGS); return -1; }
static int action_left_shader_num_passes(unsigned type, const char *label, bool wraparound) { #ifdef HAVE_SHADER_MANAGER struct video_shader *shader = NULL; menu_handle_t *menu = menu_driver_get_ptr(); if (!menu) return -1; shader = menu->shader; if (!shader) return -1; if (shader->passes) shader->passes--; menu_entries_set_refresh(false); video_shader_resolve_parameters(NULL, menu->shader); #endif return 0; }
static int action_ok_directory_push(const char *path, const char *label, unsigned type, size_t idx) { const char *menu_path = NULL; const char *menu_label = NULL; char cat_path[PATH_MAX_LENGTH]; menu_handle_t *menu = menu_driver_get_ptr(); if (!menu) return -1; if (!path) return -1; menu_list_get_last_stack(menu->menu_list, &menu_path, &menu_label, NULL); fill_pathname_join(cat_path, menu_path, path, sizeof(cat_path)); return menu_list_push_stack_refresh(menu->menu_list, cat_path, menu_label, type, idx); }
static int action_start_shader_pass(unsigned type, const char *label) { #ifdef HAVE_SHADER_MANAGER struct video_shader *shader = NULL; struct video_shader_pass *shader_pass = NULL; menu_handle_t *menu = menu_driver_get_ptr(); hack_shader_pass = type - MENU_SETTINGS_SHADER_PASS_0; if (!menu) return -1; shader = menu->shader; if (shader) shader_pass = &shader->pass[hack_shader_pass]; if (shader_pass) *shader_pass->source.path = '\0'; #endif return 0; }
static int menu_input_pointer(unsigned *action) { int pointer_device, pointer_x, pointer_y; const struct retro_keybind *binds[MAX_USERS]; menu_handle_t *menu = menu_driver_get_ptr(); settings_t *settings = config_get_ptr(); driver_t *driver = driver_get_ptr(); if (!menu) return -1; if (!settings->menu.pointer.enable) { memset(&menu->pointer, 0, sizeof(menu->pointer)); return 0; } pointer_device = driver->menu_ctx->set_texture? RETRO_DEVICE_POINTER : RARCH_DEVICE_POINTER_SCREEN; menu->pointer.pressed[0] = input_driver_state(binds, 0, pointer_device, 0, RETRO_DEVICE_ID_POINTER_PRESSED); menu->pointer.pressed[1] = input_driver_state(binds, 0, pointer_device, 1, RETRO_DEVICE_ID_POINTER_PRESSED); menu->pointer.back = input_driver_state(binds, 0, pointer_device, 0, RARCH_DEVICE_ID_POINTER_BACK); pointer_x = input_driver_state(binds, 0, pointer_device, 0, RETRO_DEVICE_ID_POINTER_X); pointer_y = input_driver_state(binds, 0, pointer_device, 0, RETRO_DEVICE_ID_POINTER_Y); menu->pointer.x = ((pointer_x + 0x7fff) * (int)menu->frame_buf.width) / 0xFFFF; menu->pointer.y = ((pointer_y + 0x7fff) * (int)menu->frame_buf.height) / 0xFFFF; if (menu->pointer.pressed[0] || menu->pointer.oldpressed[0] || menu->pointer.back || menu->pointer.dragging || menu->pointer.dy != 0 || menu->pointer.dx != 0) menu->animation_is_active = true; return 0; }
static int menu_input_mouse_frame( menu_file_list_cbs_t *cbs, menu_entry_t *entry, uint64_t input_mouse) { menu_handle_t *menu = menu_driver_get_ptr(); menu_list_t *menu_list = menu_list_get_ptr(); menu_navigation_t *nav = menu_navigation_get_ptr(); if (BIT64_GET(input_mouse, MOUSE_ACTION_BUTTON_L)) { if (BIT64_GET(input_mouse, MOUSE_ACTION_BUTTON_L_TOGGLE)) return menu_entry_action(entry, nav->selection_ptr, MENU_ACTION_RIGHT); if (BIT64_GET(input_mouse, MOUSE_ACTION_BUTTON_L_OK)) return menu_entry_action(entry, nav->selection_ptr, MENU_ACTION_OK); if (BIT64_GET(input_mouse, MOUSE_ACTION_BUTTON_L_SET_NAVIGATION)) { menu_navigation_set(nav, menu->mouse.ptr, false); } } if (BIT64_GET(input_mouse, MOUSE_ACTION_BUTTON_R)) { menu_list_pop_stack(menu_list); } if (BIT64_GET(input_mouse, MOUSE_ACTION_WHEEL_DOWN)) { menu_navigation_increment(nav, 1); } if (BIT64_GET(input_mouse, MOUSE_ACTION_WHEEL_UP)) { menu_navigation_decrement(nav, 1); } return 0; }
static int action_ok_core_load(const char *path, const char *label, unsigned type, size_t idx) { const char *menu_path = NULL; menu_handle_t *menu = menu_driver_get_ptr(); settings_t *settings = config_get_ptr(); global_t *global = global_get_ptr(); if (!menu) return -1; (void)global; menu_list_get_last_stack(menu->menu_list, &menu_path, NULL, NULL); fill_pathname_join(settings->libretro, menu_path, path, sizeof(settings->libretro)); event_command(EVENT_CMD_LOAD_CORE); menu_list_flush_stack(menu->menu_list, NULL, MENU_SETTINGS); #if defined(HAVE_DYNAMIC) /* No content needed for this core, load core immediately. */ if (menu->load_no_content && settings->core.set_supports_no_game_enable) { *global->fullpath = '\0'; menu_entries_common_load_content(false); return -1; } return 0; /* Core selection on non-console just updates directory listing. * Will take effect on new content load. */ #elif defined(RARCH_CONSOLE) event_command(EVENT_CMD_RESTART_RETROARCH); return -1; #endif }
static void menu_action_setting_disp_set_label_shader_num_passes( 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) { menu_handle_t *menu = menu_driver_get_ptr(); if (!menu) return; (void)menu; *s = '\0'; *w = 19; strlcpy(s2, path, len2); #if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_HLSL) snprintf(s, len, "%u", menu->shader->passes); #endif }
static int action_start_shader_filter_pass(unsigned type, const char *label) { #ifdef HAVE_SHADER_MANAGER unsigned pass = type - MENU_SETTINGS_SHADER_PASS_FILTER_0; struct video_shader *shader = NULL; struct video_shader_pass *shader_pass = NULL; menu_handle_t *menu = menu_driver_get_ptr(); if (!menu) return -1; shader = menu->shader; if (!shader) return -1; shader_pass = &shader->pass[pass]; if (!shader_pass) return -1; shader_pass->filter = RARCH_FILTER_UNSPEC; #endif return 0; }
static int pointer_tap(menu_file_list_cbs_t *cbs, menu_entry_t *entry, unsigned action) { menu_handle_t *menu = menu_driver_get_ptr(); menu_list_t *menu_list = menu_list_get_ptr(); menu_navigation_t *nav = menu_navigation_get_ptr(); rarch_setting_t *setting = menu_setting_find( menu_list->selection_buf->list[nav->selection_ptr].label); if (menu->pointer.ptr == nav->selection_ptr && cbs && cbs->action_right && setting && (setting->type == ST_BOOL || setting->type == ST_UINT || setting->type == ST_FLOAT || setting->type == ST_STRING)) return menu_entry_action(entry, nav->selection_ptr, MENU_ACTION_RIGHT); else if (menu->pointer.ptr == nav->selection_ptr) return menu_entry_action(entry, nav->selection_ptr, MENU_ACTION_OK); else menu_navigation_set(nav, menu->pointer.ptr, false); return 0; }
int menu_iterate_render(void) { const menu_ctx_driver_t *driver = menu_ctx_driver_get_ptr(); menu_handle_t *menu = menu_driver_get_ptr(); if (!menu) return -1; if (menu->state.fb_is_dirty != menu->state.do_messagebox) menu->state.fb_is_dirty = true; if (menu->state.fb_is_dirty) menu_display_fb_set_dirty(); if (menu->state.do_messagebox && menu->state.msg[0] != '\0') { if (driver->render_messagebox) driver->render_messagebox(menu->state.msg); if (ui_companion_is_on_foreground()) { const ui_companion_driver_t *ui = ui_companion_get_ptr(); if (ui->render_messagebox) ui->render_messagebox(menu->state.msg); } } if (menu->state.do_render) { if (driver->render) driver->render(); } if (menu_driver_alive() && !rarch_main_is_idle()) menu_display_fb(); menu_driver_set_texture(); return 0; }
static int action_ok_remap_file_load(const char *path, const char *label, unsigned type, size_t idx) { const char *menu_path = NULL; char remap_path[PATH_MAX_LENGTH]; menu_handle_t *menu = menu_driver_get_ptr(); if (!menu) return -1; (void)remap_path; (void)menu_path; menu_list_get_last_stack(menu->menu_list, &menu_path, NULL, NULL); fill_pathname_join(remap_path, menu_path, path, sizeof(remap_path)); input_remapping_load_file(remap_path); menu_list_flush_stack_by_needle(menu->menu_list, "core_input_remapping_options"); return 0; }
static void rmenu_context_reset(void) { char menu_bg[PATH_MAX_LENGTH] = {0}; menu_handle_t *menu = menu_driver_get_ptr(); settings_t *settings = config_get_ptr(); if (!menu) return; if (*settings->menu.wallpaper) strlcpy(menu_bg, settings->menu.wallpaper, sizeof(menu_bg)); else rmenu_wallpaper_set_defaults(menu_bg, sizeof(menu_bg)); if (path_file_exists(menu_bg)) texture_image_load(menu_texture, menu_bg); menu_display_ctl(MENU_DISPLAY_CTL_SET_WIDTH, &menu_texture->width); menu_display_ctl(MENU_DISPLAY_CTL_SET_HEIGHT, &menu_texture->height); menu_texture_inited = false; }
static int action_ok_cursor_manager_list(const char *path, const char *label, unsigned type, size_t idx) { char cursor_path[PATH_MAX_LENGTH]; menu_displaylist_info_t info = {0}; menu_handle_t *menu = menu_driver_get_ptr(); settings_t *settings = config_get_ptr(); if (!menu) return -1; fill_pathname_join(cursor_path, settings->cursor_directory, path, sizeof(cursor_path)); info.list = menu->menu_list->menu_stack; info.type = 0; info.directory_ptr = idx; strlcpy(info.path, cursor_path, sizeof(info.path)); strlcpy(info.label, "deferred_cursor_manager_list", sizeof(info.label)); return menu_displaylist_push_list(&info, DISPLAYLIST_GENERIC); }
static void glui_context_reset(void) { glui_handle_t *glui = NULL; menu_handle_t *menu = menu_driver_get_ptr(); settings_t *settings = config_get_ptr(); const char *font_path = NULL; if (!menu || !menu->userdata || !settings) return; glui = (glui_handle_t*)menu->userdata; font_path = settings->video.font_enable ? settings->video.font_path : NULL; if (!menu_display_init_main_font(menu, font_path, menu->display.font.size)) RARCH_WARN("Failed to load font."); glui_context_bg_destroy(glui); glui_allocate_white_texture(glui); rarch_main_data_msg_queue_push(DATA_TYPE_IMAGE, settings->menu.wallpaper, "cb_menu_wallpaper", 0, 1, true); }
static int action_toggle_scroll(unsigned type, const char *label, unsigned action, bool wraparound) { unsigned scroll_speed = 0, fast_scroll_speed = 0; menu_handle_t *menu = menu_driver_get_ptr(); if (!menu) return -1; scroll_speed = (max(menu->navigation.scroll.acceleration, 2) - 2) / 4 + 1; fast_scroll_speed = 4 + 4 * scroll_speed; switch (action) { case MENU_ACTION_LEFT: if (menu->navigation.selection_ptr > fast_scroll_speed) menu_navigation_set(&menu->navigation, menu->navigation.selection_ptr - fast_scroll_speed, true); else menu_navigation_clear(&menu->navigation, false); break; case MENU_ACTION_RIGHT: if (menu->navigation.selection_ptr + fast_scroll_speed < (menu_list_get_size(menu->menu_list))) { menu_navigation_set(&menu->navigation, menu->navigation.selection_ptr + fast_scroll_speed, true); } else { if ((menu_list_get_size(menu->menu_list) > 0)) { menu_navigation_set_last(&menu->navigation); } } break; } return 0; }
static int action_ok_file_load(const char *path, const char *label, unsigned type, size_t idx) { const char *menu_label = NULL; const char *menu_path = NULL; rarch_setting_t *setting = NULL; menu_handle_t *menu = menu_driver_get_ptr(); global_t *global = global_get_ptr(); if (!menu) return -1; menu_list_get_last(menu->menu_list->menu_stack, &menu_path, &menu_label, NULL); setting = menu_setting_find(menu_label); if (setting && setting->type == ST_PATH) { menu_action_setting_set_current_string_path(setting, menu_path, path); menu_list_pop_stack_by_needle(menu->menu_list, setting->name); } else { if (type == MENU_FILE_IN_CARCHIVE) fill_pathname_join_delim(global->fullpath, menu_path, path, '#',sizeof(global->fullpath)); else fill_pathname_join(global->fullpath, menu_path, path, sizeof(global->fullpath)); menu_entries_common_load_content(true); return -1; } return 0; }
static int action_ok_database_manager_list(const char *path, const char *label, unsigned type, size_t idx) { char rdb_path[PATH_MAX_LENGTH]; menu_handle_t *menu = menu_driver_get_ptr(); settings_t *settings = config_get_ptr(); if (!menu) return -1; if (!path) return -1; if (!label) return -1; fill_pathname_join(rdb_path, settings->content_database, path, sizeof(rdb_path)); return menu_list_push_stack_refresh( menu->menu_list, rdb_path, "deferred_database_manager_list", 0, idx); }
static void glui_blit_line(float x, float y, unsigned width, unsigned height, const char *message, uint32_t color, enum text_alignment text_align) { glui_handle_t *glui = NULL; struct font_params params = {0}; menu_handle_t *menu = menu_driver_get_ptr(); menu_display_t *disp = menu_display_get_ptr(); if (!menu) return; glui = (glui_handle_t*)menu->userdata; params.x = x / width; params.y = 1.0f - (y + glui->line_height/2 + disp->font.size/3) / height; params.scale = 1.0; params.color = color; params.full_screen = true; params.text_align = text_align; video_driver_set_osd_msg(message, ¶ms, disp->font.buf); }