void menu_entries_pop_stack(size_t *ptr, size_t idx)
{
menu_list_t *menu_list = NULL;
menu_entries_ctl(MENU_ENTRIES_CTL_LIST_GET, &menu_list);
if (menu_list)
menu_list_pop_stack(menu_list, idx, ptr);
}
static int mouse_post_iterate(menu_file_list_cbs_t *cbs, const char *path,
const char *label, unsigned type, unsigned action)
{
if (!driver.menu->mouse.enable)
return 0;
if (driver.menu->mouse.ptr <= menu_list_get_size(driver.menu->menu_list)-1)
menu_navigation_set(driver.menu, driver.menu->mouse.ptr, false);
if (driver.menu->mouse.left)
{
if (!driver.menu->mouse.oldleft)
{
driver.menu->mouse.oldleft = true;
if (cbs && cbs->action_ok)
return cbs->action_ok(path, label, type, driver.menu->selection_ptr);
}
}
else
driver.menu->mouse.oldleft = false;
if (driver.menu->mouse.right)
{
if (!driver.menu->mouse.oldright)
{
driver.menu->mouse.oldright = true;
menu_list_pop_stack(driver.menu->menu_list);
}
}
else
driver.menu->mouse.oldright = false;
return 0;
}
static void menu_list_flush_stack(menu_list_t *list,
size_t idx, const char *needle, unsigned final_type)
{
const char *path = NULL;
const char *label = NULL;
unsigned type = 0;
size_t entry_idx = 0;
if (!list)
return;
menu_entries_set_refresh(false);
menu_entries_get_last(list->menu_stack[idx],
&path, &label, &type, &entry_idx);
while (menu_entries_flush_stack_type(
needle, label, type, final_type) != 0)
{
size_t new_selection_ptr;
menu_navigation_ctl(MENU_NAVIGATION_CTL_GET_SELECTION, &new_selection_ptr);
if (!menu_list_pop_stack(list, idx, &new_selection_ptr))
break;
menu_navigation_ctl(MENU_NAVIGATION_CTL_SET_SELECTION, &new_selection_ptr);
menu_entries_get_last(list->menu_stack[idx],
&path, &label, &type, &entry_idx);
}
}
static int archive_open(void)
{
char cat_path[PATH_MAX_LENGTH];
const char *menu_path = NULL;
const char *menu_label = NULL;
const char* path = NULL;
unsigned int type = 0;
menu_handle_t *menu = menu_driver_get_ptr();
if (!menu)
return -1;
menu_list_pop_stack(menu->menu_list);
menu_list_get_last_stack(menu->menu_list,
&menu_path, &menu_label, NULL);
if (menu_list_get_size(menu->menu_list) == 0)
return 0;
menu_list_get_at_offset(menu->menu_list->selection_buf,
menu->navigation.selection_ptr, &path, NULL, &type);
fill_pathname_join(cat_path, menu_path, path, sizeof(cat_path));
menu_list_push_stack_refresh(
menu->menu_list,
cat_path,
menu_label,
type,
menu->navigation.selection_ptr);
return 0;
}
static int menu_archive_open(void)
{
char cat_path[PATH_MAX];
const char *menu_path = NULL;
const char *menu_label = NULL;
const char* path = NULL;
unsigned int type = 0;
menu_list_pop_stack(driver.menu->menu_list);
menu_list_get_last_stack(driver.menu->menu_list,
&menu_path, &menu_label, NULL);
if (menu_list_get_size(driver.menu->menu_list) == 0)
return 0;
menu_list_get_at_offset(driver.menu->menu_list->selection_buf,
driver.menu->selection_ptr, &path, NULL, &type);
fill_pathname_join(cat_path, menu_path, path, sizeof(cat_path));
menu_list_push_stack_refresh(
driver.menu->menu_list,
cat_path,
menu_label,
type,
driver.menu->selection_ptr);
return 0;
}
static void menu_list_flush_stack(menu_list_t *list,
size_t idx, const char *needle, unsigned final_type)
{
bool refresh = false;
const char *path = NULL;
const char *label = NULL;
unsigned type = 0;
size_t entry_idx = 0;
file_list_t *menu_list = menu_list_get(list, (unsigned)idx);
if (!list)
return;
menu_entries_ctl(MENU_ENTRIES_CTL_SET_REFRESH, &refresh);
file_list_get_last(menu_list,
&path, &label, &type, &entry_idx);
while (menu_list_flush_stack_type(
needle, label, type, final_type) != 0)
{
size_t new_selection_ptr = menu_navigation_get_selection();
if (!menu_list_pop_stack(list, idx, &new_selection_ptr, 1))
break;
menu_navigation_set_selection(new_selection_ptr);
menu_list = menu_list_get(list, (unsigned)idx);
file_list_get_last(menu_list,
&path, &label, &type, &entry_idx);
}
}
static int menu_input_mouse_frame(
menu_file_list_cbs_t *cbs, menu_entry_t *entry,
uint64_t input_mouse)
{
menu_input_t *menu_input = menu_input_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_SELECT);
if (BIT64_GET(input_mouse, MOUSE_ACTION_BUTTON_L_SET_NAVIGATION))
menu_navigation_set(nav, menu_input->mouse.ptr, false);
}
if (BIT64_GET(input_mouse, MOUSE_ACTION_BUTTON_R))
menu_list_pop_stack(menu_list, &nav->selection_ptr);
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_iterate_custom_bind_keyboard(const char *label, unsigned action)
{
menu_handle_t *menu = menu_driver_get_ptr();
if (!menu)
return -1;
if (menu_input_bind_iterate_keyboard())
menu_list_pop_stack(menu->menu_list);
return 0;
}
static int menu_message_toggle(unsigned action)
{
if (driver.video_data && driver.menu_ctx
&& driver.menu_ctx->render_messagebox)
driver.menu_ctx->render_messagebox(driver.menu->message_contents);
if (action == MENU_ACTION_OK)
menu_list_pop_stack(driver.menu->menu_list);
return 0;
}
static int archive_load(void)
{
int ret = 0;
menu_displaylist_info_t info = {0};
const char *menu_path = NULL;
const char *menu_label = NULL;
const char* path = NULL;
size_t entry_idx = 0;
settings_t *settings = config_get_ptr();
global_t *global = global_get_ptr();
size_t selected = menu_navigation_get_current_selection();
menu_handle_t *menu = menu_driver_get_ptr();
menu_list_t *menu_list = menu_list_get_ptr();
if (!menu || !menu_list)
return -1;
menu_list_pop_stack(menu_list);
menu_list_get_last_stack(menu_list, &menu_path, &menu_label, NULL, NULL);
if (menu_list_get_size(menu_list) == 0)
return 0;
menu_list_get_at_offset(menu_list->selection_buf,
selected, &path, NULL, NULL, &entry_idx);
ret = rarch_defer_core(global->core_info, menu_path, path, menu_label,
menu->deferred_path, sizeof(menu->deferred_path));
fill_pathname_join(detect_content_path, menu_path, path,
sizeof(detect_content_path));
switch (ret)
{
case -1:
event_command(EVENT_CMD_LOAD_CORE);
menu_common_load_content(false, CORE_TYPE_PLAIN);
break;
case 0:
info.list = menu_list->menu_stack;
info.type = 0;
info.directory_ptr = selected;
strlcpy(info.path, settings->libretro_directory, sizeof(info.path));
strlcpy(info.label,
menu_hash_to_str(MENU_LABEL_DEFERRED_CORE_LIST), sizeof(info.label));
ret = menu_displaylist_push_list(&info, DISPLAYLIST_GENERIC);
break;
}
return ret;
}
static int menu_info_screen_iterate(unsigned action)
{
char msg[PATH_MAX];
char needle[PATH_MAX];
unsigned info_type = 0;
rarch_setting_t *current_setting = NULL;
file_list_t *list = (file_list_t*)driver.menu->menu_list->selection_buf;
if (!driver.menu)
return 0;
if (driver.video_data && driver.menu_ctx && driver.menu_ctx->render)
driver.menu_ctx->render();
current_setting = (rarch_setting_t*)setting_data_find_setting(
driver.menu->list_settings,
list->list[driver.menu->selection_ptr].label);
if (current_setting)
strlcpy(needle, current_setting->name, sizeof(needle));
else if ((current_setting = (rarch_setting_t*)setting_data_find_setting(
driver.menu->list_mainmenu,
list->list[driver.menu->selection_ptr].label)))
{
if (current_setting)
strlcpy(needle, current_setting->name, sizeof(needle));
}
else
{
const char *label = NULL;
menu_list_get_at_offset(driver.menu->menu_list->selection_buf,
driver.menu->selection_ptr, NULL, &label,
&info_type);
if (label)
strlcpy(needle, label, sizeof(needle));
}
setting_data_get_description(needle, msg, sizeof(msg));
if (driver.video_data && driver.menu_ctx &&
driver.menu_ctx->render_messagebox)
{
if (*msg && msg[0] != '\0')
driver.menu_ctx->render_messagebox(msg);
}
if (action == MENU_ACTION_OK)
menu_list_pop_stack(driver.menu->menu_list);
return 0;
}
static int action_iterate_message(const char *label, unsigned action)
{
menu_handle_t *menu = menu_driver_get_ptr();
if (!menu)
return -1;
menu_driver_render_messagebox(menu->message_contents);
if (action == MENU_ACTION_OK)
menu_list_pop_stack(menu->menu_list);
return 0;
}
/* Clicks the back button */
int menu_entry_go_back(void)
{
menu_list_t *menu_list = menu_list_get_ptr();
if (!menu_list)
return -1;
menu_setting_apply_deferred();
menu_list_pop_stack(menu_list);
if (menu_entries_needs_refresh())
menu_entries_refresh(MENU_ACTION_CANCEL);
rarch_main_data_iterate();
return 0;
}
static int archive_load(void)
{
int ret;
const char *menu_path = NULL;
const char *menu_label = NULL;
const char* path = NULL;
unsigned int type = 0;
menu_handle_t *menu = menu_driver_get_ptr();
settings_t *settings = config_get_ptr();
global_t *global = global_get_ptr();
if (!menu)
return -1;
menu_list_pop_stack(menu->menu_list);
menu_list_get_last_stack(menu->menu_list,
&menu_path, &menu_label, NULL);
if (menu_list_get_size(menu->menu_list) == 0)
return 0;
menu_list_get_at_offset(menu->menu_list->selection_buf,
menu->navigation.selection_ptr, &path, NULL, &type);
ret = rarch_defer_core(global->core_info, menu_path, path, menu_label,
menu->deferred_path, sizeof(menu->deferred_path));
switch (ret)
{
case -1:
event_command(EVENT_CMD_LOAD_CORE);
menu_entries_common_load_content(false);
break;
case 0:
menu_list_push_stack_refresh(
menu->menu_list,
settings->libretro_directory,
"deferred_core_list",
0,
menu->navigation.selection_ptr);
break;
}
return 0;
}
static int menu_input_mouse_frame(
menu_file_list_cbs_t *cbs, menu_entry_t *entry,
uint64_t input_mouse)
{
size_t selection;
menu_input_t *menu_input = menu_input_get_ptr();
menu_list_t *menu_list = menu_list_get_ptr();
menu_navigation_ctl(MENU_NAVIGATION_CTL_GET_SELECTION, &selection);
if (BIT64_GET(input_mouse, MOUSE_ACTION_BUTTON_L))
{
if (BIT64_GET(input_mouse, MOUSE_ACTION_BUTTON_L_TOGGLE))
return menu_entry_action(entry, selection, MENU_ACTION_SELECT);
if (BIT64_GET(input_mouse, MOUSE_ACTION_BUTTON_L_SET_NAVIGATION))
{
size_t idx = menu_input->mouse.ptr;
bool scroll = false;
menu_navigation_ctl(MENU_NAVIGATION_CTL_SET_SELECTION, &idx);
menu_navigation_ctl(MENU_NAVIGATION_CTL_SET, &scroll);
}
}
if (BIT64_GET(input_mouse, MOUSE_ACTION_BUTTON_R))
{
menu_list_pop_stack(menu_list, &selection);
menu_navigation_ctl(MENU_NAVIGATION_CTL_SET_SELECTION, &selection);
}
if (BIT64_GET(input_mouse, MOUSE_ACTION_WHEEL_DOWN))
{
unsigned increment_by = 1;
menu_navigation_ctl(MENU_NAVIGATION_CTL_INCREMENT, &increment_by);
}
if (BIT64_GET(input_mouse, MOUSE_ACTION_WHEEL_UP))
{
unsigned decrement_by = 1;
menu_navigation_ctl(MENU_NAVIGATION_CTL_DECREMENT, &decrement_by);
}
return 0;
}
static int menu_archive_load(void)
{
int ret;
const char *menu_path = NULL;
const char *menu_label = NULL;
const char* path = NULL;
unsigned int type = 0;
menu_list_pop_stack(driver.menu->menu_list);
menu_list_get_last_stack(driver.menu->menu_list,
&menu_path, &menu_label, NULL);
if (menu_list_get_size(driver.menu->menu_list) == 0)
return 0;
menu_list_get_at_offset(driver.menu->menu_list->selection_buf,
driver.menu->selection_ptr, &path, NULL, &type);
ret = rarch_defer_core(g_extern.core_info, menu_path, path,
driver.menu->deferred_path, sizeof(driver.menu->deferred_path));
switch (ret)
{
case -1:
rarch_main_command(RARCH_CMD_LOAD_CORE);
menu_common_load_content();
break;
case 0:
menu_list_push_stack_refresh(
driver.menu->menu_list,
g_settings.libretro_directory,
"deferred_core_list",
0,
driver.menu->selection_ptr);
break;
}
return 0;
}
static int archive_open(void)
{
char cat_path[PATH_MAX_LENGTH] = {0};
menu_displaylist_info_t info = {0};
const char *menu_path = NULL;
const char *menu_label = NULL;
const char* path = NULL;
unsigned int type = 0;
size_t entry_idx = 0;
menu_navigation_t *nav = menu_navigation_get_ptr();
menu_list_t *menu_list = menu_list_get_ptr();
if (!menu_list || !nav)
return -1;
menu_list_pop_stack(menu_list);
menu_list_get_last_stack(menu_list,
&menu_path, &menu_label, NULL, NULL);
if (menu_list_get_size(menu_list) == 0)
return 0;
menu_list_get_at_offset(menu_list->selection_buf,
nav->selection_ptr, &path, NULL, &type, &entry_idx);
fill_pathname_join(cat_path, menu_path, path, sizeof(cat_path));
fill_pathname_join(detect_content_path, menu_path, path,
sizeof(detect_content_path));
info.list = menu_list->menu_stack;
info.type = type;
info.directory_ptr = nav->selection_ptr;
strlcpy(info.path, cat_path, sizeof(info.path));
strlcpy(info.label, menu_label, sizeof(info.label));
return menu_displaylist_push_list(&info, DISPLAYLIST_GENERIC);
}
static int menu_input_mouse_post_iterate(menu_file_list_cbs_t *cbs,
const char *path,
const char *label, unsigned type, unsigned action)
{
driver_t *driver = driver_get_ptr();
menu_handle_t *menu = menu_driver_get_ptr();
settings_t *settings = config_get_ptr();
if (!menu)
return -1;
if (!settings->menu.mouse.enable
#ifdef HAVE_OVERLAY
|| (settings->input.overlay_enable && driver && driver->overlay)
#endif
)
{
menu->mouse.wheeldown = false;
menu->mouse.wheelup = false;
menu->mouse.oldleft = false;
menu->mouse.oldright = false;
return 0;
}
if (menu->mouse.left)
{
if (!menu->mouse.oldleft)
{
rarch_setting_t *setting =
(rarch_setting_t*)setting_find_setting
(menu->list_settings,
menu->menu_list->selection_buf->list[menu->navigation.selection_ptr].label);
menu->mouse.oldleft = true;
#if 0
RARCH_LOG("action OK: %d\n", cbs && cbs->action_ok);
RARCH_LOG("action toggle: %d\n", cbs && cbs->action_toggle);
if (setting && setting->type)
RARCH_LOG("action type: %d\n", setting->type);
#endif
if (menu->mouse.ptr == menu->navigation.selection_ptr
&& cbs && cbs->action_toggle && setting &&
(setting->type == ST_BOOL || setting->type == ST_UINT || setting->type == ST_FLOAT
|| setting->type == ST_STRING))
return cbs->action_toggle(type, label, MENU_ACTION_RIGHT, true);
if (menu->mouse.ptr == menu->navigation.selection_ptr
&& cbs && cbs->action_ok)
return cbs->action_ok(path, label, type,
menu->navigation.selection_ptr);
else if (menu->mouse.ptr <= menu_list_get_size(menu->menu_list)-1)
menu_navigation_set(&menu->navigation, menu->mouse.ptr, false);
}
}
else
menu->mouse.oldleft = false;
if (menu->mouse.right)
{
if (!menu->mouse.oldright)
{
menu->mouse.oldright = true;
menu_list_pop_stack(menu->menu_list);
}
}
else
menu->mouse.oldright = false;
if (menu->mouse.wheeldown)
menu_navigation_increment(&menu->navigation, 1);
if (menu->mouse.wheelup)
menu_navigation_decrement(&menu->navigation, 1);
return 0;
}
void menu_entries_pop_stack(size_t *ptr, size_t idx, bool animate)
{
menu_list_t *menu_list = menu_entries_list;
if (menu_list)
menu_list_pop_stack(menu_list, idx, ptr, animate);
}
/**
* 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 menu_iterate(bool render_this_frame, unsigned action)
{
menu_entry_t entry;
enum action_iterate_type iterate_type;
size_t selected;
const char *label = NULL;
int ret = 0;
uint32_t hash = 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();
if (render_this_frame)
menu_animation_update_time();
menu_list_get_last_stack(menu_list, NULL, &label, NULL, NULL);
if (!menu || !menu_list)
return 0;
menu->state.fb_is_dirty = false;
menu->state.do_messagebox = false;
menu->state.do_render = false;
menu->state.do_pop_stack = false;
menu->state.do_post_iterate = false;
menu->state.pop_selected = NULL;
menu->state.msg[0] = '\0';
hash = menu_hash_calculate(label);
iterate_type = action_iterate_type(hash);
if (action != MENU_ACTION_NOOP || menu_entries_needs_refresh() || menu_display_update_pending())
{
if (render_this_frame)
menu->state.fb_is_dirty = true;
}
switch (iterate_type)
{
case ITERATE_TYPE_HELP:
ret = action_iterate_help(menu->state.msg, sizeof(menu->state.msg), label);
if (render_this_frame)
menu->state.do_render = true;
menu->state.pop_selected = NULL;
menu->state.do_messagebox = true;
menu->state.do_pop_stack = true;
menu->state.do_post_iterate = true;
if (ret == 1)
action = MENU_ACTION_OK;
break;
case ITERATE_TYPE_BIND:
if (menu_input_bind_iterate(menu->state.msg, sizeof(menu->state.msg)))
menu_list_pop_stack(menu_list, &nav->selection_ptr);
else
menu->state.do_messagebox = true;
if (render_this_frame)
menu->state.do_render = true;
break;
case ITERATE_TYPE_VIEWPORT:
ret = action_iterate_menu_viewport(menu->state.msg, sizeof(menu->state.msg), label, action, hash);
if (render_this_frame)
menu->state.do_render = true;
menu->state.do_messagebox = true;
break;
case ITERATE_TYPE_INFO:
ret = action_iterate_info(menu->state.msg, sizeof(menu->state.msg), label);
menu->state.pop_selected = &nav->selection_ptr;
if (render_this_frame)
menu->state.do_render = true;
menu->state.do_messagebox = true;
menu->state.do_pop_stack = true;
menu->state.do_post_iterate = true;
break;
case ITERATE_TYPE_MESSAGE:
strlcpy(menu->state.msg, disp->message_contents, sizeof(menu->state.msg));
menu->state.pop_selected = &nav->selection_ptr;
menu->state.do_messagebox = true;
menu->state.do_pop_stack = true;
break;
case ITERATE_TYPE_DEFAULT:
selected = menu_navigation_get_selection(nav);
/* 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)
goto end;
menu->state.do_post_iterate = true;
if (render_this_frame)
menu->state.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;
}
if (menu->state.do_pop_stack && action == MENU_ACTION_OK)
menu_list_pop_stack(menu_list, menu->state.pop_selected);
if (menu->state.do_post_iterate)
menu_input_post_iterate(&ret, action);
end:
if (ret)
return -1;
return 0;
}
static int action_iterate_menu_viewport(const char *label, unsigned action)
{
int stride_x = 1, stride_y = 1;
char msg[PATH_MAX_LENGTH];
struct retro_game_geometry *geom = NULL;
const char *base_msg = NULL;
unsigned type = 0;
global_t *global = global_get_ptr();
video_viewport_t *custom = &global->console.screen.viewports.custom_vp;
menu_handle_t *menu = menu_driver_get_ptr();
settings_t *settings = config_get_ptr();
if (!menu)
return -1;
menu_list_get_last_stack(menu->menu_list, NULL, NULL, &type);
geom = (struct retro_game_geometry*)&global->system.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->menu_list);
if (!strcmp(label, "custom_viewport_2"))
{
menu_list_push_stack(menu->menu_list, "", "",
MENU_SETTINGS_CUSTOM_VIEWPORT,
menu->navigation.selection_ptr);
}
break;
case MENU_ACTION_OK:
menu_list_pop_stack(menu->menu_list);
if (type == MENU_SETTINGS_CUSTOM_VIEWPORT
&& !settings->video.scale_integer)
{
menu_list_push_stack(menu->menu_list, "",
"custom_viewport_2", 0, menu->navigation.selection_ptr);
}
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:
menu->msg_force = true;
break;
default:
break;
}
menu_list_get_last_stack(menu->menu_list, NULL, &label, &type);
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(msg, sizeof(msg), "%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 = "Set Upper-Left Corner";
else if (!strcmp(label, "custom_viewport_2"))
base_msg = "Set Bottom-Right Corner";
snprintf(msg, sizeof(msg), "%s (%d, %d : %4ux%4u)",
base_msg, custom->x, custom->y, custom->width, custom->height);
}
menu_driver_render_messagebox(msg);
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 menu_input_mouse_post_iterate(uint64_t *input_mouse,
menu_file_list_cbs_t *cbs,
menu_entry_t *entry, unsigned action)
{
driver_t *driver = driver_get_ptr();
settings_t *settings = config_get_ptr();
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();
*input_mouse = MOUSE_ACTION_NONE;
if (!menu)
return -1;
if (!settings->menu.mouse.enable
#ifdef HAVE_OVERLAY
|| (settings->input.overlay_enable && driver && driver->overlay)
#endif
)
{
menu->mouse.wheeldown = false;
menu->mouse.wheelup = false;
menu->mouse.oldleft = false;
menu->mouse.oldright = false;
return 0;
}
if (menu->mouse.left)
{
if (!menu->mouse.oldleft)
{
BIT64_SET(*input_mouse, MOUSE_ACTION_BUTTON_L);
rarch_setting_t *setting = menu_setting_find(
menu_list->selection_buf->list[nav->selection_ptr].label);
menu->mouse.oldleft = true;
if (menu->mouse.y < menu->header_height)
{
menu_list_pop_stack(menu_list);
return 0;
}
if (menu->mouse.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))
{
BIT64_SET(*input_mouse, MOUSE_ACTION_BUTTON_L_TOGGLE);
}
else if (menu->mouse.ptr == nav->selection_ptr
&& cbs && cbs->action_ok)
{
BIT64_SET(*input_mouse, MOUSE_ACTION_BUTTON_L_OK);
}
else if (menu->mouse.ptr <= menu_list_get_size(menu_list)-1)
{
BIT64_SET(*input_mouse, MOUSE_ACTION_BUTTON_L_SET_NAVIGATION);
}
}
}
else
menu->mouse.oldleft = false;
if (menu->mouse.right)
{
if (!menu->mouse.oldright)
{
menu->mouse.oldright = true;
BIT64_SET(*input_mouse, MOUSE_ACTION_BUTTON_R);
}
}
else
menu->mouse.oldright = false;
if (menu->mouse.wheeldown)
{
BIT64_SET(*input_mouse, MOUSE_ACTION_WHEEL_DOWN);
}
if (menu->mouse.wheelup)
{
BIT64_SET(*input_mouse, MOUSE_ACTION_WHEEL_UP);
}
return 0;
}
static int menu_input_pointer_post_iterate(menu_file_list_cbs_t *cbs,
menu_entry_t *entry, unsigned action)
{
int ret = 0;
menu_handle_t *menu = menu_driver_get_ptr();
driver_t *driver = driver_get_ptr();
settings_t *settings = config_get_ptr();
if (!menu)
return -1;
if (!settings->menu.pointer.enable
#ifdef HAVE_OVERLAY
|| (settings->input.overlay_enable && driver && driver->overlay)
#endif
)
return 0;
if (menu->pointer.pressed[0])
{
if (!menu->pointer.oldpressed[0])
{
menu->pointer.start_x = menu->pointer.x;
menu->pointer.start_y = menu->pointer.y;
menu->pointer.old_x = menu->pointer.x;
menu->pointer.old_y = menu->pointer.y;
menu->pointer.oldpressed[0] = true;
}
else if (menu->pointer.x != menu->pointer.start_x
&& menu->pointer.y != menu->pointer.start_y)
{
menu->pointer.dragging = true;
menu->pointer.dx = menu->pointer.x - menu->pointer.old_x;
menu->pointer.dy = menu->pointer.y - menu->pointer.old_y;
menu->pointer.old_x = menu->pointer.x;
menu->pointer.old_y = menu->pointer.y;
}
}
else
{
if (menu->pointer.oldpressed[0])
{
if (!menu->pointer.dragging)
{
if (menu->pointer.start_y < menu->header_height)
{
menu_list_pop_stack(menu->menu_list);
}
else if (menu->pointer.ptr <= menu_list_get_size(menu->menu_list)-1)
{
menu->pointer.oldpressed[0] = false;
ret = pointer_tap(cbs, entry, action);
}
}
menu->pointer.oldpressed[0] = false;
menu->pointer.start_x = 0;
menu->pointer.start_y = 0;
menu->pointer.old_x = 0;
menu->pointer.old_y = 0;
menu->pointer.dx = 0;
menu->pointer.dy = 0;
menu->pointer.dragging = false;
}
}
if (menu->pointer.back)
{
if (!menu->pointer.oldback)
{
menu->pointer.oldback = true;
menu_list_pop_stack(menu->menu_list);
}
}
menu->pointer.oldback = menu->pointer.back;
return ret;
}
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 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 menu_input_pointer_post_iterate(menu_file_list_cbs_t *cbs,
const char *path,
const char *label, unsigned type, unsigned action)
{
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
#ifdef HAVE_OVERLAY
|| (settings->input.overlay_enable && driver && driver->overlay)
#endif
)
return 0;
#if defined(HAVE_XMB)
if (driver->menu_ctx == &menu_ctx_xmb)
return 0;
#endif
if (menu->pointer.pressed[0])
{
if (menu->pointer.oldpressed[0])
{
if (menu->mouse.ptr <= menu_list_get_size(menu->menu_list)-1)
menu_navigation_set(&menu->navigation, menu->mouse.ptr, false);
}
else
menu->pointer.oldpressed[0] = true;
}
else
{
if (menu->pointer.oldpressed[0])
{
rarch_setting_t *setting = NULL;
menu->pointer.oldpressed[0] = false;
setting = (rarch_setting_t*)setting_find_setting
(menu->list_settings,
menu->menu_list->selection_buf->list[menu->navigation.selection_ptr].label);
if (menu->mouse.ptr == menu->navigation.selection_ptr && !menu->pointer.cancel
&& cbs && cbs->action_toggle && setting &&
(setting->type == ST_BOOL || setting->type == ST_UINT || setting->type == ST_FLOAT
|| setting->type == ST_STRING))
return cbs->action_toggle(type, label, MENU_ACTION_RIGHT, true);
if (menu->mouse.ptr == menu->navigation.selection_ptr && !menu->pointer.cancel
&& cbs && cbs->action_ok)
return cbs->action_ok(path, label, type,
menu->navigation.selection_ptr);
else if (menu->mouse.ptr <= menu_list_get_size(menu->menu_list) - 1)
menu_navigation_set(&menu->navigation, menu->mouse.ptr, false);
}
}
if (menu->pointer.back)
{
if (!menu->pointer.oldback)
{
menu->pointer.oldback = true;
menu_list_pop_stack(menu->menu_list);
}
}
menu->pointer.oldback = menu->pointer.back;
return 0;
}
static int menu_input_mouse_post_iterate(uint64_t *input_mouse,
menu_file_list_cbs_t *cbs, unsigned action)
{
settings_t *settings = config_get_ptr();
menu_display_t *disp = menu_display_get_ptr();
menu_input_t *menu_input = menu_input_get_ptr();
menu_list_t *menu_list = menu_list_get_ptr();
menu_navigation_t *nav = menu_navigation_get_ptr();
*input_mouse = MOUSE_ACTION_NONE;
if (!settings->menu.mouse.enable
#ifdef HAVE_OVERLAY
|| (settings->input.overlay_enable && input_overlay_is_alive())
#endif
)
{
menu_input->mouse.wheeldown = false;
menu_input->mouse.wheelup = false;
menu_input->mouse.oldleft = false;
menu_input->mouse.oldright = false;
return 0;
}
if (menu_input->mouse.left)
{
if (!menu_input->mouse.oldleft)
{
BIT64_SET(*input_mouse, MOUSE_ACTION_BUTTON_L);
menu_input->mouse.oldleft = true;
if ((unsigned)menu_input->mouse.y < disp->header_height)
{
menu_list_pop_stack(menu_list, &nav->selection_ptr);
return 0;
}
if (
(menu_input->mouse.ptr == nav->selection_ptr) &&
cbs &&
cbs->action_select )
{
BIT64_SET(*input_mouse, MOUSE_ACTION_BUTTON_L_TOGGLE);
}
else if (menu_input->mouse.ptr <= menu_list_get_size(menu_list)-1)
{
BIT64_SET(*input_mouse, MOUSE_ACTION_BUTTON_L_SET_NAVIGATION);
}
}
}
else
menu_input->mouse.oldleft = false;
if (menu_input->mouse.right)
{
if (!menu_input->mouse.oldright)
{
menu_input->mouse.oldright = true;
BIT64_SET(*input_mouse, MOUSE_ACTION_BUTTON_R);
}
}
else
menu_input->mouse.oldright = false;
if (menu_input->mouse.wheeldown)
{
BIT64_SET(*input_mouse, MOUSE_ACTION_WHEEL_DOWN);
}
if (menu_input->mouse.wheelup)
{
BIT64_SET(*input_mouse, MOUSE_ACTION_WHEEL_UP);
}
return 0;
}
static int menu_input_pointer_post_iterate(menu_file_list_cbs_t *cbs,
menu_entry_t *entry, unsigned action)
{
unsigned header_height;
size_t selection;
int ret = 0;
menu_list_t *menu_list = menu_list_get_ptr();
menu_input_t *menu_input = menu_input_get_ptr();
settings_t *settings = config_get_ptr();
if (!menu_input)
return -1;
if (!menu_navigation_ctl(MENU_NAVIGATION_CTL_GET_SELECTION, &selection))
return -1;
menu_display_ctl(MENU_DISPLAY_CTL_HEADER_HEIGHT, &header_height);
if (!settings->menu.pointer.enable
#ifdef HAVE_OVERLAY
|| (settings->input.overlay_enable && input_overlay_is_alive())
#endif
)
return 0;
if (menu_input->pointer.pressed[0])
{
int16_t pointer_x = menu_input_pointer_state(MENU_POINTER_X_AXIS);
int16_t pointer_y = menu_input_pointer_state(MENU_POINTER_Y_AXIS);
if (!menu_input->pointer.oldpressed[0])
{
menu_input->pointer.accel = 0;
menu_input->pointer.accel0 = 0;
menu_input->pointer.accel1 = 0;
menu_input->pointer.start_x = pointer_x;
menu_input->pointer.start_y = pointer_y;
menu_input->pointer.old_x = pointer_x;
menu_input->pointer.old_y = pointer_y;
menu_input->pointer.oldpressed[0] = true;
}
else if (abs(pointer_x - menu_input->pointer.start_x) > 3
|| abs(pointer_y - menu_input->pointer.start_y) > 3)
{
float s, delta_time;
menu_input->pointer.dragging = true;
menu_input->pointer.dx = pointer_x - menu_input->pointer.old_x;
menu_input->pointer.dy = pointer_y - menu_input->pointer.old_y;
menu_input->pointer.old_x = pointer_x;
menu_input->pointer.old_y = pointer_y;
menu_animation_ctl(MENU_ANIMATION_CTL_DELTA_TIME, &delta_time);
s = menu_input->pointer.dy / delta_time * 1000000.0;
menu_input->pointer.accel = (menu_input->pointer.accel0 + menu_input->pointer.accel1 + s) / 3;
menu_input->pointer.accel0 = menu_input->pointer.accel1;
menu_input->pointer.accel1 = menu_input->pointer.accel;
}
}
else
{
if (menu_input->pointer.oldpressed[0])
{
if (!menu_input->pointer.dragging)
{
if ((unsigned)menu_input->pointer.start_y < header_height)
{
menu_list_pop_stack(menu_list, &selection);
menu_navigation_ctl(MENU_NAVIGATION_CTL_SET_SELECTION, &selection);
}
else if (menu_input->pointer.ptr <= menu_list_get_size(menu_list)-1)
{
menu_input->pointer.oldpressed[0] = false;
ret = pointer_tap(cbs, entry, action);
}
}
menu_input->pointer.oldpressed[0] = false;
menu_input->pointer.start_x = 0;
menu_input->pointer.start_y = 0;
menu_input->pointer.old_x = 0;
menu_input->pointer.old_y = 0;
menu_input->pointer.dx = 0;
menu_input->pointer.dy = 0;
menu_input->pointer.dragging = false;
}
}
if (menu_input->pointer.back)
{
if (!menu_input->pointer.oldback)
{
menu_input->pointer.oldback = true;
menu_list_pop_stack(menu_list, &selection);
menu_navigation_ctl(MENU_NAVIGATION_CTL_SET_SELECTION, &selection);
}
}
menu_input->pointer.oldback = menu_input->pointer.back;
return ret;
}
void menu_entries_pop_stack(size_t *ptr, size_t idx)
{
menu_list_t *menu_list = menu_list_get_ptr();
if (menu_list)
menu_list_pop_stack(menu_list, idx, ptr);
}
static int menu_input_pointer_post_iterate(menu_file_list_cbs_t *cbs,
menu_entry_t *entry, unsigned action)
{
int ret = 0;
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();
menu_input_t *menu_input = menu_input_get_ptr();
settings_t *settings = config_get_ptr();
if (!menu_input)
return -1;
if (!settings->menu.pointer.enable
#ifdef HAVE_OVERLAY
|| (settings->input.overlay_enable && input_overlay_is_alive())
#endif
)
return 0;
if (menu_input->pointer.pressed[0])
{
if (!menu_input->pointer.oldpressed[0])
{
menu_input->pointer.accel = 0;
menu_input->pointer.accel0 = 0;
menu_input->pointer.accel1 = 0;
menu_input->pointer.start_x = menu_input->pointer.x;
menu_input->pointer.start_y = menu_input->pointer.y;
menu_input->pointer.old_x = menu_input->pointer.x;
menu_input->pointer.old_y = menu_input->pointer.y;
menu_input->pointer.oldpressed[0] = true;
}
else if (abs(menu_input->pointer.x - menu_input->pointer.start_x) > 3
|| abs(menu_input->pointer.y - menu_input->pointer.start_y) > 3)
{
float s;
menu_input->pointer.dragging = true;
menu_input->pointer.dx = menu_input->pointer.x - menu_input->pointer.old_x;
menu_input->pointer.dy = menu_input->pointer.y - menu_input->pointer.old_y;
menu_input->pointer.old_x = menu_input->pointer.x;
menu_input->pointer.old_y = menu_input->pointer.y;
s = menu_input->pointer.dy / menu_animation_get_delta_time(disp->animation) * 1000000.0;
menu_input->pointer.accel = (menu_input->pointer.accel0 + menu_input->pointer.accel1 + s) / 3;
menu_input->pointer.accel0 = menu_input->pointer.accel1;
menu_input->pointer.accel1 = menu_input->pointer.accel;
}
}
else
{
if (menu_input->pointer.oldpressed[0])
{
if (!menu_input->pointer.dragging)
{
if ((unsigned)menu_input->pointer.start_y < disp->header_height)
menu_list_pop_stack(menu_list, &nav->selection_ptr);
else if (menu_input->pointer.ptr <= menu_list_get_size(menu_list)-1)
{
menu_input->pointer.oldpressed[0] = false;
ret = pointer_tap(cbs, entry, action);
}
}
menu_input->pointer.oldpressed[0] = false;
menu_input->pointer.start_x = 0;
menu_input->pointer.start_y = 0;
menu_input->pointer.old_x = 0;
menu_input->pointer.old_y = 0;
menu_input->pointer.dx = 0;
menu_input->pointer.dy = 0;
menu_input->pointer.dragging = false;
}
}
if (menu_input->pointer.back)
{
if (!menu_input->pointer.oldback)
{
menu_input->pointer.oldback = true;
menu_list_pop_stack(menu_list, &nav->selection_ptr);
}
}
menu_input->pointer.oldback = menu_input->pointer.back;
return ret;
}