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