static int deferred_push_input_osk_overlay(menu_displaylist_info_t *info)
{
return menu_displaylist_push_list(info, DISPLAYLIST_OVERLAYS);
}
static int deferred_push_core_options(menu_displaylist_info_t *info)
{
return menu_displaylist_push_list(info, DISPLAYLIST_CORE_OPTIONS);
}
static int deferred_push_core_updater_list(menu_displaylist_info_t *info)
{
return menu_displaylist_push_list(info, DISPLAYLIST_CORES_UPDATER);
}
static int deferred_push_management_options(menu_displaylist_info_t *info)
{
return menu_displaylist_push_list(info, DISPLAYLIST_OPTIONS_MANAGEMENT);
}
static int deferred_push_frontend_counters(menu_displaylist_info_t *info)
{
return menu_displaylist_push_list(info, DISPLAYLIST_PERFCOUNTERS_FRONTEND);
}
static int deferred_push_settings(menu_displaylist_info_t *info)
{
return menu_displaylist_push_list(info, DISPLAYLIST_SETTINGS_ALL);
}
static int deferred_push_category(menu_displaylist_info_t *info)
{
info->flags = SL_FLAG_ALL_SETTINGS;
return menu_displaylist_push_list(info, DISPLAYLIST_SETTINGS);
}
static int deferred_push_rpl_entry_actions(menu_displaylist_info_t *info)
{
return menu_displaylist_push_list(info, DISPLAYLIST_HORIZONTAL_CONTENT_ACTIONS);
}
/**
* menu_iterate:
* @input : input sample for this frame
* @old_input : input sample of the previous frame
* @trigger_input : difference' input sample - difference
* between 'input' and 'old_input'
*
* Runs RetroArch menu for one frame.
*
* Returns: 0 on success, -1 if we need to quit out of the loop.
**/
int generic_menu_iterate(void *data, void *userdata, enum menu_action action)
{
size_t selection;
menu_entry_t entry;
enum action_iterate_type iterate_type;
const char *label = NULL;
int ret = 0;
uint32_t label_hash = 0;
uint32_t hash = 0;
menu_handle_t *menu = (menu_handle_t*)data;
file_list_t *menu_stack = menu_entries_get_menu_stack_ptr(0);
file_list_t *selection_buf = menu_entries_get_selection_buf_ptr(0);
menu_entries_get_last_stack(NULL, &label, NULL, NULL);
if (!menu)
return 0;
if (!menu_navigation_ctl(MENU_NAVIGATION_CTL_GET_SELECTION, &selection))
return 0;
menu->menu_state.msg[0] = '\0';
hash = menu_hash_calculate(label);
iterate_type = action_iterate_type(hash);
if ( action != MENU_ACTION_NOOP
|| menu_entries_ctl(MENU_ENTRIES_CTL_NEEDS_REFRESH, NULL)
|| menu_display_ctl(MENU_DISPLAY_CTL_UPDATE_PENDING, NULL))
{
BIT64_SET(menu->state, MENU_STATE_RENDER_FRAMEBUFFER);
}
switch (iterate_type)
{
case ITERATE_TYPE_HELP:
ret = action_iterate_help(menu,
menu->menu_state.msg, sizeof(menu->menu_state.msg), label);
BIT64_SET(menu->state, MENU_STATE_RENDER_MESSAGEBOX);
BIT64_SET(menu->state, MENU_STATE_POST_ITERATE);
if (ret == 1 || action == MENU_ACTION_OK)
BIT64_SET(menu->state, MENU_STATE_POP_STACK);
break;
case ITERATE_TYPE_BIND:
if (menu_input_key_bind_iterate(
menu->menu_state.msg, sizeof(menu->menu_state.msg)))
{
menu_entries_pop_stack(&selection, 0);
menu_navigation_ctl(MENU_NAVIGATION_CTL_SET_SELECTION, &selection);
}
else
BIT64_SET(menu->state, MENU_STATE_RENDER_MESSAGEBOX);
break;
case ITERATE_TYPE_INFO:
{
menu_file_list_cbs_t *cbs =
menu_entries_get_actiondata_at_offset(selection_buf, selection);
rarch_setting_t *setting = cbs->setting;
if (setting)
{
char needle[PATH_MAX_LENGTH];
strlcpy(needle, menu_setting_get_name(setting), sizeof(needle));
label_hash = menu_hash_calculate(needle);
}
ret = menu_hash_get_help(label_hash,
menu->menu_state.msg, sizeof(menu->menu_state.msg));
}
BIT64_SET(menu->state, MENU_STATE_RENDER_MESSAGEBOX);
BIT64_SET(menu->state, MENU_STATE_POST_ITERATE);
if (action == MENU_ACTION_OK)
BIT64_SET(menu->state, MENU_STATE_POP_STACK);
break;
case ITERATE_TYPE_DEFAULT:
/* FIXME: Crappy hack, needed for mouse controls to not be completely broken
* in case we press back.
*
* We need to fix this entire mess, mouse controls should not rely on a
* hack like this in order to work. */
selection = max(min(selection, (menu_entries_get_size() - 1)), 0);
menu_entry_get(&entry, 0, selection, NULL, false);
ret = menu_entry_action(&entry, selection, (enum menu_action)action);
if (ret)
goto end;
BIT64_SET(menu->state, MENU_STATE_POST_ITERATE);
/* Have to defer it so we let settings refresh. */
if (menu->push_help_screen)
{
menu_displaylist_info_t info = {0};
info.list = menu_stack;
strlcpy(info.label,
menu_hash_to_str(MENU_LABEL_HELP),
sizeof(info.label));
menu_displaylist_push_list(&info, DISPLAYLIST_HELP);
}
break;
}
BIT64_SET(menu->state, MENU_STATE_BLIT);
if (BIT64_GET(menu->state, MENU_STATE_POP_STACK))
{
size_t new_selection_ptr = selection;
menu_entries_pop_stack(&new_selection_ptr, 0);
menu_navigation_ctl(MENU_NAVIGATION_CTL_SET_SELECTION, &selection);
}
if (BIT64_GET(menu->state, MENU_STATE_POST_ITERATE))
menu_input_post_iterate(&ret, action);
end:
if (ret)
return -1;
return 0;
}
static int deferred_push_help(menu_displaylist_info_t *info)
{
return menu_displaylist_push_list(info, DISPLAYLIST_HELP_SCREEN_LIST);
}
static int deferred_push_rdb_entry_detail(menu_displaylist_info_t *info)
{
return menu_displaylist_push_list(info, DISPLAYLIST_DATABASE_ENTRY);
}
static int deferred_push_rdb_collection(menu_displaylist_info_t *info)
{
return menu_displaylist_push_list(info, DISPLAYLIST_PLAYLIST_COLLECTION);
}
static int deferred_push_content_history_path(menu_displaylist_info_t *info)
{
return menu_displaylist_push_list(info, DISPLAYLIST_CONTENT_HISTORY);
}
static int deferred_push_video_font_path(menu_displaylist_info_t *info)
{
return menu_displaylist_push_list(info, DISPLAYLIST_FONTS);
}
static int deferred_push_performance_counters(menu_displaylist_info_t *info)
{
return menu_displaylist_push_list(info, DISPLAYLIST_PERFCOUNTER_SELECTION);
}
static int deferred_push_core_information(menu_displaylist_info_t *info)
{
return menu_displaylist_push_list(info, DISPLAYLIST_CORE_INFO);
}
static int deferred_push_video_shader_parameters(menu_displaylist_info_t *info)
{
return menu_displaylist_push_list(info, DISPLAYLIST_SHADER_PARAMETERS);
}
static int deferred_push_system_information(menu_displaylist_info_t *info)
{
return menu_displaylist_push_list(info, DISPLAYLIST_SYSTEM_INFO);
}
static int deferred_push_settings_subgroup(menu_displaylist_info_t *info)
{
return menu_displaylist_push_list(info, DISPLAYLIST_SETTINGS_SUBGROUP);
}
static int deferred_push_rdb_collection(menu_displaylist_info_t *info)
{
/* TODO/FIXME - add path? */
return menu_displaylist_push_list(info, DISPLAYLIST_PLAYLIST_COLLECTION);
}
static int deferred_push_shader_options(menu_displaylist_info_t *info)
{
return menu_displaylist_push_list(info, DISPLAYLIST_OPTIONS_SHADERS);
}
static int deferred_push_core_collection_list_deferred(menu_displaylist_info_t *info)
{
return menu_displaylist_push_list(info, DISPLAYLIST_CORES_COLLECTION_SUPPORTED);
}
static int deferred_push_core_counters(menu_displaylist_info_t *info)
{
return menu_displaylist_push_list(info, DISPLAYLIST_PERFCOUNTERS_CORE);
}
static int action_iterate_menu_viewport(char *s, size_t len,
const char *label, unsigned action, uint32_t hash)
{
int stride_x = 1, stride_y = 1;
menu_displaylist_info_t info = {0};
struct retro_game_geometry *geom = NULL;
const char *base_msg = NULL;
unsigned type = 0;
video_viewport_t *custom = video_viewport_get_custom();
menu_display_t *disp = menu_display_get_ptr();
menu_navigation_t *nav = menu_navigation_get_ptr();
menu_list_t *menu_list = menu_list_get_ptr();
settings_t *settings = config_get_ptr();
struct retro_system_av_info *av_info = video_viewport_get_system_av_info();
if (!menu_list)
return -1;
menu_list_get_last_stack(menu_list, NULL, NULL, &type, NULL);
geom = (struct retro_game_geometry*)&av_info->geometry;
if (settings->video.scale_integer)
{
stride_x = geom->base_width;
stride_y = geom->base_height;
}
switch (action)
{
case MENU_ACTION_UP:
if (type == MENU_SETTINGS_CUSTOM_VIEWPORT)
{
custom->y -= stride_y;
custom->height += stride_y;
}
else if (custom->height >= (unsigned)stride_y)
custom->height -= stride_y;
event_command(EVENT_CMD_VIDEO_APPLY_STATE_CHANGES);
break;
case MENU_ACTION_DOWN:
if (type == MENU_SETTINGS_CUSTOM_VIEWPORT)
{
custom->y += stride_y;
if (custom->height >= (unsigned)stride_y)
custom->height -= stride_y;
}
else
custom->height += stride_y;
event_command(EVENT_CMD_VIDEO_APPLY_STATE_CHANGES);
break;
case MENU_ACTION_LEFT:
if (type == MENU_SETTINGS_CUSTOM_VIEWPORT)
{
custom->x -= stride_x;
custom->width += stride_x;
}
else if (custom->width >= (unsigned)stride_x)
custom->width -= stride_x;
event_command(EVENT_CMD_VIDEO_APPLY_STATE_CHANGES);
break;
case MENU_ACTION_RIGHT:
if (type == MENU_SETTINGS_CUSTOM_VIEWPORT)
{
custom->x += stride_x;
if (custom->width >= (unsigned)stride_x)
custom->width -= stride_x;
}
else
custom->width += stride_x;
event_command(EVENT_CMD_VIDEO_APPLY_STATE_CHANGES);
break;
case MENU_ACTION_CANCEL:
menu_list_pop_stack(menu_list);
if (hash == MENU_LABEL_CUSTOM_VIEWPORT_2)
{
info.list = menu_list->menu_stack;
info.type = MENU_SETTINGS_CUSTOM_VIEWPORT;
info.directory_ptr = nav->selection_ptr;
menu_displaylist_push_list(&info, DISPLAYLIST_INFO);
}
break;
case MENU_ACTION_OK:
menu_list_pop_stack(menu_list);
if (type == MENU_SETTINGS_CUSTOM_VIEWPORT
&& !settings->video.scale_integer)
{
info.list = menu_list->menu_stack;
strlcpy(info.label,
menu_hash_to_str(MENU_LABEL_CUSTOM_VIEWPORT_2),
sizeof(info.label));
info.type = 0;
info.directory_ptr = nav->selection_ptr;
menu_displaylist_push_list(&info, DISPLAYLIST_INFO);
}
break;
case MENU_ACTION_START:
if (!settings->video.scale_integer)
{
video_viewport_t vp;
video_driver_viewport_info(&vp);
if (type == MENU_SETTINGS_CUSTOM_VIEWPORT)
{
custom->width += custom->x;
custom->height += custom->y;
custom->x = 0;
custom->y = 0;
}
else
{
custom->width = vp.full_width - custom->x;
custom->height = vp.full_height - custom->y;
}
event_command(EVENT_CMD_VIDEO_APPLY_STATE_CHANGES);
}
break;
case MENU_ACTION_MESSAGE:
if (disp)
disp->msg_force = true;
break;
default:
break;
}
menu_list_get_last_stack(menu_list, NULL, &label, &type, NULL);
menu_driver_render();
if (settings->video.scale_integer)
{
custom->x = 0;
custom->y = 0;
custom->width = ((custom->width + geom->base_width - 1) /
geom->base_width) * geom->base_width;
custom->height = ((custom->height + geom->base_height - 1) /
geom->base_height) * geom->base_height;
base_msg = "Set scale";
snprintf(s, len, "%s (%4ux%4u, %u x %u scale)",
base_msg,
custom->width, custom->height,
custom->width / geom->base_width,
custom->height / geom->base_height);
}
else
{
if (type == MENU_SETTINGS_CUSTOM_VIEWPORT)
base_msg = menu_hash_to_str(MENU_LABEL_VALUE_CUSTOM_VIEWPORT_1);
else if (hash == MENU_LABEL_CUSTOM_VIEWPORT_2)
base_msg = menu_hash_to_str(MENU_LABEL_VALUE_CUSTOM_VIEWPORT_2);
snprintf(s, len, "%s (%d, %d : %4ux%4u)",
base_msg, custom->x, custom->y, custom->width, custom->height);
}
menu_driver_render_messagebox(s);
if (!custom->width)
custom->width = stride_x;
if (!custom->height)
custom->height = stride_y;
aspectratio_lut[ASPECT_RATIO_CUSTOM].value =
(float)custom->width / custom->height;
event_command(EVENT_CMD_VIDEO_APPLY_STATE_CHANGES);
return 0;
}
static int deferred_push_core_input_remapping_options(menu_displaylist_info_t *info)
{
return menu_displaylist_push_list(info, DISPLAYLIST_OPTIONS_REMAPPINGS);
}
static int action_iterate_main(const char *label, unsigned action)
{
menu_entry_t entry;
static bool did_messagebox = false;
char msg[PATH_MAX_LENGTH] = {0};
enum action_iterate_type iterate_type;
size_t selected;
size_t *pop_selected = NULL;
bool do_messagebox = false;
bool do_pop_stack = false;
bool do_post_iterate = false;
bool do_render = false;
int ret = 0;
menu_handle_t *menu = menu_driver_get_ptr();
menu_navigation_t *nav = menu_navigation_get_ptr();
menu_display_t *disp = menu_display_get_ptr();
menu_list_t *menu_list = menu_list_get_ptr();
uint32_t hash = menu_hash_calculate(label);
if (!menu || !menu_list)
return 0;
iterate_type = action_iterate_type(hash);
switch (iterate_type)
{
case ITERATE_TYPE_HELP:
ret = action_iterate_help(msg, sizeof(msg), label);
pop_selected = NULL;
do_messagebox = true;
do_pop_stack = true;
do_post_iterate = true;
if (ret == 1)
action = MENU_ACTION_OK;
break;
case ITERATE_TYPE_BIND:
if (menu_input_bind_iterate())
menu_list_pop_stack(menu_list);
break;
case ITERATE_TYPE_VIEWPORT:
ret = action_iterate_menu_viewport(msg, sizeof(msg), label, action, hash);
break;
case ITERATE_TYPE_INFO:
ret = action_iterate_info(msg, sizeof(msg), label);
pop_selected = &nav->selection_ptr;
do_messagebox = true;
do_pop_stack = true;
do_post_iterate = true;
break;
case ITERATE_TYPE_MESSAGE:
strlcpy(msg, disp->message_contents, sizeof(msg));
pop_selected = &nav->selection_ptr;
do_messagebox = true;
do_pop_stack = true;
break;
case ITERATE_TYPE_DEFAULT:
selected = menu_navigation_get_current_selection();
/* FIXME: selected > selection_buf->list->size, i don't know why. */
selected = max(min(selected, menu_list_get_size(menu_list)-1), 0);
menu_entry_get(&entry, selected, NULL, false);
ret = menu_entry_action(&entry, selected, (enum menu_action)action);
if (ret)
return ret;
do_post_iterate = true;
do_render = true;
/* Have to defer it so we let settings refresh. */
if (menu->push_help_screen)
{
menu_displaylist_info_t info = {0};
info.list = menu_list->menu_stack;
strlcpy(info.label,
menu_hash_to_str(MENU_LABEL_HELP),
sizeof(info.label));
menu_displaylist_push_list(&info, DISPLAYLIST_HELP);
}
break;
}
did_messagebox = did_messagebox != do_messagebox;
if (did_messagebox)
menu_display_fb_set_dirty();
if (do_messagebox)
menu_driver_render_messagebox(msg);
if (do_pop_stack && action == MENU_ACTION_OK)
menu_list_pop(menu_list->menu_stack, pop_selected);
if (do_post_iterate)
menu_input_post_iterate(&ret, action);
if (do_render)
menu_driver_render();
return ret;
}
static int deferred_push_disk_options(menu_displaylist_info_t *info)
{
return menu_displaylist_push_list(info, DISPLAYLIST_OPTIONS_DISK);
}
static int menu_input_key_bind_set_mode_common(rarch_setting_t *setting,
enum menu_input_bind_mode type)
{
size_t selection;
unsigned index_offset, bind_type;
menu_displaylist_info_t info = {0};
struct retro_keybind *keybind = NULL;
file_list_t *menu_stack = NULL;
settings_t *settings = config_get_ptr();
menu_input_t *menu_input = menu_input_get_ptr();
if (!setting)
return -1;
index_offset = menu_setting_get_index_offset(setting);
menu_stack = menu_entries_get_menu_stack_ptr(0);
menu_navigation_ctl(MENU_NAVIGATION_CTL_GET_SELECTION, &selection);
switch (type)
{
case MENU_INPUT_BIND_NONE:
return -1;
case MENU_INPUT_BIND_SINGLE:
keybind = (struct retro_keybind*)setting_get_ptr(setting);
if (!keybind)
return -1;
bind_type = menu_setting_get_bind_type(setting);
menu_input->binds.begin = bind_type;
menu_input->binds.last = bind_type;
menu_input->binds.target = keybind;
menu_input->binds.user = index_offset;
info.list = menu_stack;
info.type = MENU_SETTINGS_CUSTOM_BIND_KEYBOARD;
info.directory_ptr = selection;
strlcpy(info.label,
menu_hash_to_str(MENU_LABEL_CUSTOM_BIND), sizeof(info.label));
if (menu_displaylist_push_list(&info, DISPLAYLIST_INFO) == 0)
menu_displaylist_push_list_process(&info);
break;
case MENU_INPUT_BIND_ALL:
menu_input->binds.target = &settings->input.binds
[index_offset][0];
menu_input->binds.begin = MENU_SETTINGS_BIND_BEGIN;
menu_input->binds.last = MENU_SETTINGS_BIND_LAST;
info.list = menu_stack;
info.type = MENU_SETTINGS_CUSTOM_BIND_KEYBOARD;
info.directory_ptr = selection;
strlcpy(info.label,
menu_hash_to_str(MENU_LABEL_CUSTOM_BIND_ALL),
sizeof(info.label));
if (menu_displaylist_push_list(&info, DISPLAYLIST_INFO) == 0)
menu_displaylist_push_list_process(&info);
break;
}
return 0;
}
static int deferred_push_history_list(menu_displaylist_info_t *info)
{
return menu_displaylist_push_list(info, DISPLAYLIST_HISTORY);
}
static int deferred_push_record_configfile(menu_displaylist_info_t *info)
{
return menu_displaylist_push_list(info, DISPLAYLIST_RECORD_CONFIG_FILES);
}
