void menu_entries_push(file_list_t *list, const char *path, const char *label,
unsigned type, size_t directory_ptr, size_t entry_idx)
{
menu_ctx_list_t list_info;
size_t idx;
menu_file_list_cbs_t *cbs = NULL;
if (!list || !label)
return;
file_list_push(list, path, label, type, directory_ptr, entry_idx);
idx = list->size - 1;
list_info.list = list;
list_info.path = path;
list_info.label = label;
list_info.idx = idx;
menu_driver_ctl(RARCH_MENU_CTL_LIST_INSERT, &list_info);
file_list_free_actiondata(list, idx);
cbs = (menu_file_list_cbs_t*)
calloc(1, sizeof(menu_file_list_cbs_t));
if (!cbs)
return;
file_list_set_actiondata(list, idx, cbs);
cbs->setting = menu_setting_find(label);
menu_cbs_init(list, cbs, path, label, type, idx);
}
void menu_entries_push(file_list_t *list, const char *path, const char *label,
unsigned type, size_t directory_ptr, size_t entry_idx)
{
size_t idx;
const menu_ctx_driver_t *driver = menu_ctx_driver_get_ptr();
menu_file_list_cbs_t *cbs = NULL;
if (!list || !label)
return;
file_list_push(list, path, label, type, directory_ptr, entry_idx);
idx = list->size - 1;
if (driver->list_insert)
driver->list_insert(list, path, label, idx);
file_list_free_actiondata(list, idx);
cbs = (menu_file_list_cbs_t*)
calloc(1, sizeof(menu_file_list_cbs_t));
if (!cbs)
return;
file_list_set_actiondata(list, idx, cbs);
cbs->setting = menu_setting_find(label);
menu_cbs_init(list, cbs, path, label, type, idx);
}
void *menu_init(void)
{
rgui_handle_t *rgui;
rgui = NULL;
if (!driver.menu_ctx)
{
RARCH_ERR("menu_init() - menu context interface not initialized.\n");
return NULL;
}
if (!driver.image)
{
RARCH_ERR("Image driver not initialized.\n");
RARCH_WARN("Trying to bring up image driver interface.\n");
find_image_driver();
if (!driver.image)
RARCH_ERR("Still couldn't initialize image driver.\n");
}
if (driver.menu_ctx->init)
rgui = (rgui_handle_t*)driver.menu_ctx->init();
if (!rgui)
return NULL;
strlcpy(g_settings.menu.driver, driver.menu_ctx->ident, sizeof(g_settings.menu.driver));
rgui->menu_stack = (file_list_t*)calloc(1, sizeof(file_list_t));
rgui->selection_buf = (file_list_t*)calloc(1, sizeof(file_list_t));
file_list_push(rgui->menu_stack, "", RGUI_SETTINGS, 0);
menu_clear_navigation(rgui);
rgui->push_start_screen = g_settings.rgui_show_start_screen;
g_settings.rgui_show_start_screen = false;
if (driver.menu_ctx && driver.menu_ctx->backend && driver.menu_ctx->backend->entries_init)
driver.menu_ctx->backend->entries_init(rgui, RGUI_SETTINGS);
rgui->trigger_state = 0;
rgui->old_input_state = 0;
rgui->do_held = false;
rgui->frame_buf_show = true;
rgui->current_pad = 0;
menu_update_libretro_info(rgui);
if (driver.menu_ctx && driver.menu_ctx->backend && driver.menu_ctx->backend->shader_manager_init)
driver.menu_ctx->backend->shader_manager_init(rgui);
menu_init_history(rgui);
rgui->last_time = rarch_get_time_usec();
return rgui;
}
void menu_list_push(file_list_t *list,
const char *path, const char *label,
unsigned type, size_t directory_ptr)
{
if (!list || !label)
return;
file_list_push(list, path, label, type, directory_ptr);
menu_list_insert(list, path, label, type, directory_ptr);
}
void *menu_init(const void *data)
{
menu_handle_t *menu;
menu_ctx_driver_t *menu_ctx = (menu_ctx_driver_t*)data;
if (!menu_ctx)
return NULL;
if (!(menu = (menu_handle_t*)menu_ctx->init()))
return NULL;
strlcpy(g_settings.menu.driver, menu_ctx->ident,
sizeof(g_settings.menu.driver));
menu->menu_stack = (file_list_t*)calloc(1, sizeof(file_list_t));
menu->selection_buf = (file_list_t*)calloc(1, sizeof(file_list_t));
menu->core_info_current = (core_info_t*)calloc(1, sizeof(core_info_t));
#ifdef HAVE_SHADER_MANAGER
menu->shader = (struct gfx_shader*)calloc(1, sizeof(struct gfx_shader));
#endif
file_list_push(menu->menu_stack, "", "", MENU_SETTINGS, 0);
menu_clear_navigation(menu);
menu->push_start_screen = g_settings.menu_show_start_screen;
g_settings.menu_show_start_screen = false;
if (menu_ctx && menu_ctx->backend && menu_ctx->backend->entries_init)
menu_ctx->backend->entries_init(menu, MENU_SETTINGS);
menu->trigger_state = 0;
menu->old_input_state = 0;
menu->do_held = false;
menu->frame_buf_show = true;
menu->current_pad = 0;
menu_update_libretro_info(menu);
if (menu_ctx && menu_ctx->backend
&& menu_ctx->backend->shader_manager_init)
menu_ctx->backend->shader_manager_init(menu);
rarch_main_command(RARCH_CMD_HISTORY_INIT);
menu->last_time = rarch_get_time_usec();
return menu;
}
void menu_list_push(file_list_t *list,
const char *path, const char *label,
unsigned type, size_t directory_ptr)
{
if (!list)
return;
file_list_push(list, path, label, type, directory_ptr);
if (!driver.menu_ctx)
return;
if (driver.menu_ctx->list_insert)
driver.menu_ctx->list_insert(list, path, label, list->size - 1);
if (driver.menu_ctx->backend->list_insert)
driver.menu_ctx->backend->list_insert(list, path,
label, type, list->size - 1);
}
void menu_push_info_screen(void)
{
file_list_push(driver.menu->menu_stack, "", "help", 0, 0);
}
static int menu_action_ok(const char *menu_path,
const char *menu_label, unsigned menu_type)
{
const char *label = NULL;
const char *path = NULL;
unsigned type = 0;
rarch_setting_t *setting_data = (rarch_setting_t *)driver.menu->list_settings;
rarch_setting_t *setting = (rarch_setting_t*)
setting_data_find_setting(setting_data, menu_label);
(void)hack_shader_pass;
if (file_list_get_size(driver.menu->selection_buf) == 0)
return 0;
file_list_get_at_offset(driver.menu->selection_buf,
driver.menu->selection_ptr, &path, &label, &type);
#if 0
RARCH_LOG("menu label: %s\n", menu_label);
RARCH_LOG("type : %d\n", type == MENU_FILE_USE_DIRECTORY);
RARCH_LOG("type id : %d\n", type);
#endif
while (true)
{
switch (type)
{
case MENU_FILE_PLAYLIST_ENTRY:
rarch_playlist_load_content(g_defaults.history,
driver.menu->selection_ptr);
menu_flush_stack_type(driver.menu->menu_stack, MENU_SETTINGS);
return -1;
#ifdef HAVE_COMPRESSION
case MENU_FILE_IN_CARCHIVE:
#endif
case MENU_FILE_PLAIN:
if (!strcmp(menu_label, "detect_core_list"))
{
int ret = rarch_defer_core(g_extern.core_info,
menu_path, path, driver.menu->deferred_path,
sizeof(driver.menu->deferred_path));
if (ret == -1)
{
rarch_main_command(RARCH_CMD_LOAD_CORE);
menu_common_load_content();
return -1;
}
else if (ret == 0)
menu_entries_push(driver.menu->menu_stack,
g_settings.libretro_directory, "deferred_core_list",
0, driver.menu->selection_ptr);
}
else if ((setting && setting->type == ST_PATH))
{
menu_action_setting_set_current_string_path(setting, menu_path, path);
menu_entries_pop_stack(driver.menu->menu_stack, setting->name);
}
else if (!strcmp(menu_label, "disk_image_append"))
{
char image[PATH_MAX];
fill_pathname_join(image, menu_path, path, sizeof(image));
rarch_disk_control_append_image(image);
rarch_main_command(RARCH_CMD_RESUME);
menu_flush_stack_type(driver.menu->menu_stack,MENU_SETTINGS);
return -1;
}
else
{
if (type == MENU_FILE_IN_CARCHIVE)
{
fill_pathname_join_delim(g_extern.fullpath, menu_path, path,
'#',sizeof(g_extern.fullpath));
}
else
{
fill_pathname_join(g_extern.fullpath, menu_path, path,
sizeof(g_extern.fullpath));
}
menu_common_load_content();
rarch_main_command(RARCH_CMD_LOAD_CONTENT_PERSIST);
menu_flush_stack_type(driver.menu->menu_stack,MENU_SETTINGS);
driver.menu->msg_force = true;
return -1;
}
return 0;
case MENU_FILE_CONFIG:
{
char config[PATH_MAX];
fill_pathname_join(config, menu_path, path, sizeof(config));
menu_flush_stack_type(driver.menu->menu_stack,MENU_SETTINGS);
driver.menu->msg_force = true;
if (rarch_replace_config(config))
{
menu_clear_navigation(driver.menu);
return -1;
}
}
return 0;
case MENU_FILE_FONT:
case MENU_FILE_OVERLAY:
case MENU_FILE_AUDIOFILTER:
case MENU_FILE_VIDEOFILTER:
menu_action_setting_set_current_string_path(setting, menu_path, path);
menu_entries_pop_stack(driver.menu->menu_stack, setting->name);
return 0;
case MENU_FILE_SHADER_PRESET:
#ifdef HAVE_SHADER_MANAGER
{
char shader_path[PATH_MAX];
fill_pathname_join(shader_path, menu_path, path, sizeof(shader_path));
menu_shader_manager_set_preset(driver.menu->shader,
gfx_shader_parse_type(shader_path, RARCH_SHADER_NONE),
shader_path);
menu_flush_stack_label(driver.menu->menu_stack, "Shader Options");
}
#endif
return 0;
case MENU_FILE_SHADER:
#ifdef HAVE_SHADER_MANAGER
fill_pathname_join(driver.menu->shader->pass[hack_shader_pass].source.path,
menu_path, path,
sizeof(driver.menu->shader->pass[hack_shader_pass].source.path));
/* This will reset any changed parameters. */
gfx_shader_resolve_parameters(NULL, driver.menu->shader);
menu_flush_stack_label(driver.menu->menu_stack, "Shader Options");
#endif
return 0;
case MENU_FILE_CORE:
if (!strcmp(menu_label, "deferred_core_list"))
{
strlcpy(g_settings.libretro, path, sizeof(g_settings.libretro));
strlcpy(g_extern.fullpath, driver.menu->deferred_path,
sizeof(g_extern.fullpath));
menu_common_load_content();
return -1;
}
else if (!strcmp(menu_label, "core_list"))
{
fill_pathname_join(g_settings.libretro, menu_path, path,
sizeof(g_settings.libretro));
rarch_main_command(RARCH_CMD_LOAD_CORE);
menu_flush_stack_type(driver.menu->menu_stack,MENU_SETTINGS);
#if defined(HAVE_DYNAMIC)
/* No content needed for this core, load core immediately. */
if (driver.menu->load_no_content)
{
*g_extern.fullpath = '\0';
menu_common_load_content();
return -1;
}
/* Core selection on non-console just updates directory listing.
* Will take effect on new content load. */
#elif defined(RARCH_CONSOLE)
rarch_main_command(RARCH_CMD_RESTART_RETROARCH);
return -1;
#endif
}
return 0;
case MENU_FILE_USE_DIRECTORY:
if (setting && setting->type == ST_DIR)
{
menu_action_setting_set_current_string(setting, menu_path);
menu_entries_pop_stack(driver.menu->menu_stack, setting->name);
}
return 0;
case MENU_FILE_DIRECTORY:
case MENU_FILE_CARCHIVE:
{
char cat_path[PATH_MAX];
if (type == MENU_FILE_CARCHIVE && !strcmp(menu_label, "detect_core_list"))
{
file_list_push(driver.menu->menu_stack, path, "load_open_zip",
0, driver.menu->selection_ptr);
return 0;
}
fill_pathname_join(cat_path, menu_path, path, sizeof(cat_path));
menu_entries_push(driver.menu->menu_stack,
cat_path, menu_label, type, driver.menu->selection_ptr);
}
return 0;
}
break;
}
if (menu_parse_check(label, type) == 0)
{
char cat_path[PATH_MAX];
fill_pathname_join(cat_path, menu_path, path, sizeof(cat_path));
menu_entries_push(driver.menu->menu_stack,
cat_path, menu_label, type, driver.menu->selection_ptr);
}
return 0;
}
static int menu_viewport_iterate(unsigned action)
{
int stride_x = 1, stride_y = 1;
char msg[64];
struct retro_game_geometry *geom = NULL;
const char *base_msg = NULL;
const char *label = NULL;
unsigned menu_type = 0;
rarch_viewport_t *custom = (rarch_viewport_t*)
&g_extern.console.screen.viewports.custom_vp;
file_list_get_last(driver.menu->menu_stack, NULL, &label, &menu_type);
geom = (struct retro_game_geometry*)&g_extern.system.av_info.geometry;
if (g_settings.video.scale_integer)
{
stride_x = geom->base_width;
stride_y = geom->base_height;
}
switch (action)
{
case MENU_ACTION_UP:
if (menu_type == MENU_SETTINGS_CUSTOM_VIEWPORT)
{
custom->y -= stride_y;
custom->height += stride_y;
}
else if (custom->height >= (unsigned)stride_y)
custom->height -= stride_y;
rarch_main_command(RARCH_CMD_VIDEO_APPLY_STATE_CHANGES);
break;
case MENU_ACTION_DOWN:
if (menu_type == MENU_SETTINGS_CUSTOM_VIEWPORT)
{
custom->y += stride_y;
if (custom->height >= (unsigned)stride_y)
custom->height -= stride_y;
}
else
custom->height += stride_y;
rarch_main_command(RARCH_CMD_VIDEO_APPLY_STATE_CHANGES);
break;
case MENU_ACTION_LEFT:
if (menu_type == MENU_SETTINGS_CUSTOM_VIEWPORT)
{
custom->x -= stride_x;
custom->width += stride_x;
}
else if (custom->width >= (unsigned)stride_x)
custom->width -= stride_x;
rarch_main_command(RARCH_CMD_VIDEO_APPLY_STATE_CHANGES);
break;
case MENU_ACTION_RIGHT:
if (menu_type == MENU_SETTINGS_CUSTOM_VIEWPORT)
{
custom->x += stride_x;
if (custom->width >= (unsigned)stride_x)
custom->width -= stride_x;
}
else
custom->width += stride_x;
rarch_main_command(RARCH_CMD_VIDEO_APPLY_STATE_CHANGES);
break;
case MENU_ACTION_CANCEL:
menu_entries_pop(driver.menu->menu_stack);
if (!strcmp(label, "custom_viewport_2"))
{
file_list_push(driver.menu->menu_stack, "", "",
MENU_SETTINGS_CUSTOM_VIEWPORT,
driver.menu->selection_ptr);
}
break;
case MENU_ACTION_OK:
menu_entries_pop(driver.menu->menu_stack);
if (menu_type == MENU_SETTINGS_CUSTOM_VIEWPORT
&& !g_settings.video.scale_integer)
{
file_list_push(driver.menu->menu_stack, "",
"custom_viewport_2", 0, driver.menu->selection_ptr);
}
break;
case MENU_ACTION_START:
if (!g_settings.video.scale_integer)
{
rarch_viewport_t vp;
if (driver.video_data && driver.video &&
driver.video->viewport_info)
driver.video->viewport_info(driver.video_data, &vp);
if (menu_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;
}
rarch_main_command(RARCH_CMD_VIDEO_APPLY_STATE_CHANGES);
}
break;
case MENU_ACTION_MESSAGE:
driver.menu->msg_force = true;
break;
default:
break;
}
file_list_get_last(driver.menu->menu_stack, NULL, &label, &menu_type);
if (driver.video_data && driver.menu_ctx && driver.menu_ctx->render)
driver.menu_ctx->render();
if (g_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 (menu_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);
}
if (driver.video_data && driver.menu_ctx &&
driver.menu_ctx->render_messagebox)
driver.menu_ctx->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;
rarch_main_command(RARCH_CMD_VIDEO_APPLY_STATE_CHANGES);
return 0;
}
static int menu_settings_iterate(unsigned action)
{
const char *path = NULL;
const char *dir = NULL;
const char *label = NULL;
unsigned type = 0;
unsigned menu_type = 0;
driver.menu->frame_buf_pitch = driver.menu->width * 2;
if (action != MENU_ACTION_REFRESH)
file_list_get_at_offset(driver.menu->selection_buf,
driver.menu->selection_ptr, NULL, &label, &type);
if (!strcmp(label, "core_list"))
dir = g_settings.libretro_directory;
else if (!strcmp(label, "configurations"))
dir = g_settings.menu_config_directory;
else if (!strcmp(label, "disk_image_append"))
dir = g_settings.menu_content_directory;
if (driver.menu->need_refresh && action != MENU_ACTION_MESSAGE)
action = MENU_ACTION_NOOP;
switch (action)
{
case MENU_ACTION_UP:
if (driver.menu->selection_ptr > 0)
menu_decrement_navigation(driver.menu);
else
menu_set_navigation(driver.menu,
file_list_get_size(driver.menu->selection_buf) - 1);
break;
case MENU_ACTION_DOWN:
if ((driver.menu->selection_ptr + 1) <
file_list_get_size(driver.menu->selection_buf))
menu_increment_navigation(driver.menu);
else
menu_clear_navigation(driver.menu);
break;
case MENU_ACTION_CANCEL:
menu_entries_pop(driver.menu->menu_stack);
break;
case MENU_ACTION_SELECT:
file_list_push(driver.menu->menu_stack, "", "info_screen",
0, driver.menu->selection_ptr);
break;
case MENU_ACTION_OK:
if (menu_setting_ok_toggle(type, dir, label, action) == 0)
return 0;
/* fall-through */
case MENU_ACTION_START:
if (menu_setting_start_toggle(type, dir, label, action) == 0)
return 0;
/* fall-through */
case MENU_ACTION_LEFT:
case MENU_ACTION_RIGHT:
{
int ret = menu_setting_toggle(type, dir,
label, action);
if (ret)
return ret;
}
break;
case MENU_ACTION_REFRESH:
menu_clear_navigation(driver.menu);
driver.menu->need_refresh = true;
break;
case MENU_ACTION_MESSAGE:
driver.menu->msg_force = true;
break;
default:
break;
}
file_list_get_last(driver.menu->menu_stack, &path, &label, &menu_type);
if (driver.menu->need_refresh && (menu_parse_check(label, menu_type) == -1))
{
driver.menu->need_refresh = false;
menu_entries_push_list(driver.menu,
driver.menu->selection_buf, path, label, menu_type);
}
if (driver.menu_ctx && driver.menu_ctx->render)
driver.menu_ctx->render();
/* Have to defer it so we let settings refresh. */
if (driver.menu->push_start_screen)
{
driver.menu->push_start_screen = false;
file_list_push(driver.menu->menu_stack, "", "help", 0, 0);
}
return 0;
}
static int menu_setting_ok_toggle(unsigned type,
const char *dir, const char *label,
unsigned action)
{
if (type == MENU_SETTINGS_CUSTOM_BIND_ALL)
{
driver.menu->binds.target = &g_settings.input.binds
[driver.menu->current_pad][0];
driver.menu->binds.begin = MENU_SETTINGS_BIND_BEGIN;
driver.menu->binds.last = MENU_SETTINGS_BIND_LAST;
file_list_push(driver.menu->menu_stack, "", "",
driver.menu->bind_mode_keyboard ?
MENU_SETTINGS_CUSTOM_BIND_KEYBOARD :
MENU_SETTINGS_CUSTOM_BIND,
driver.menu->selection_ptr);
if (driver.menu->bind_mode_keyboard)
{
driver.menu->binds.timeout_end =
rarch_get_time_usec() +
MENU_KEYBOARD_BIND_TIMEOUT_SECONDS * 1000000;
input_keyboard_wait_keys(driver.menu,
menu_custom_bind_keyboard_cb);
}
else
{
menu_poll_bind_get_rested_axes(&driver.menu->binds);
menu_poll_bind_state(&driver.menu->binds);
}
return 0;
}
#ifdef HAVE_SHADER_MANAGER
else if (!strcmp(label, "video_shader_preset_save_as"))
{
if (action == MENU_ACTION_OK)
menu_key_start_line(driver.menu, "Preset Filename",
label, st_string_callback);
}
else if (!strcmp(label, "shader_apply_changes"))
{
rarch_main_command(RARCH_CMD_SHADERS_APPLY_CHANGES);
return 0;
}
#endif
else if (type == MENU_SETTINGS_CUSTOM_BIND_DEFAULT_ALL)
{
unsigned i;
struct retro_keybind *target = (struct retro_keybind*)
&g_settings.input.binds[driver.menu->current_pad][0];
const struct retro_keybind *def_binds =
driver.menu->current_pad ? retro_keybinds_rest : retro_keybinds_1;
driver.menu->binds.begin = MENU_SETTINGS_BIND_BEGIN;
driver.menu->binds.last = MENU_SETTINGS_BIND_LAST;
for (i = MENU_SETTINGS_BIND_BEGIN;
i <= MENU_SETTINGS_BIND_LAST; i++, target++)
{
if (driver.menu->bind_mode_keyboard)
target->key = def_binds[i - MENU_SETTINGS_BIND_BEGIN].key;
else
{
target->joykey = NO_BTN;
target->joyaxis = AXIS_NONE;
}
}
return 0;
}
else if (type >= MENU_SETTINGS_BIND_BEGIN &&
type <= MENU_SETTINGS_BIND_ALL_LAST)
{
struct retro_keybind *bind = (struct retro_keybind*)
&g_settings.input.binds[driver.menu->current_pad]
[type - MENU_SETTINGS_BIND_BEGIN];
driver.menu->binds.begin = type;
driver.menu->binds.last = type;
driver.menu->binds.target = bind;
driver.menu->binds.player = driver.menu->current_pad;
file_list_push(driver.menu->menu_stack, "", "",
driver.menu->bind_mode_keyboard ?
MENU_SETTINGS_CUSTOM_BIND_KEYBOARD : MENU_SETTINGS_CUSTOM_BIND,
driver.menu->selection_ptr);
if (driver.menu->bind_mode_keyboard)
{
driver.menu->binds.timeout_end = rarch_get_time_usec() +
MENU_KEYBOARD_BIND_TIMEOUT_SECONDS * 1000000;
input_keyboard_wait_keys(driver.menu,
menu_custom_bind_keyboard_cb);
}
else
{
menu_poll_bind_get_rested_axes(&driver.menu->binds);
menu_poll_bind_state(&driver.menu->binds);
}
return 0;
}
else if (
!strcmp(label, "load_content") ||
!strcmp(label, "detect_core_list")
)
{
menu_entries_push(driver.menu->menu_stack,
g_settings.menu_content_directory, label, MENU_FILE_DIRECTORY,
driver.menu->selection_ptr);
return 0;
}
else if (!strcmp(label, "history_list") ||
menu_common_type_is(label, type) == MENU_FILE_DIRECTORY
)
{
menu_entries_push(driver.menu->menu_stack,
"", label, type, driver.menu->selection_ptr);
return 0;
}
else if (
menu_common_type_is(label, type) == MENU_SETTINGS ||
!strcmp(label, "core_list") ||
!strcmp(label, "configurations") ||
!strcmp(label, "disk_image_append")
)
{
menu_entries_push(driver.menu->menu_stack,
dir ? dir : label, label, type,
driver.menu->selection_ptr);
return 0;
}
else if (type == MENU_SETTINGS_CUSTOM_VIEWPORT)
{
file_list_push(driver.menu->menu_stack, "", "",
MENU_SETTINGS_CUSTOM_VIEWPORT,
driver.menu->selection_ptr);
/* Start with something sane. */
rarch_viewport_t *custom = (rarch_viewport_t*)
&g_extern.console.screen.viewports.custom_vp;
if (driver.video_data && driver.video &&
driver.video->viewport_info)
driver.video->viewport_info(driver.video_data, custom);
aspectratio_lut[ASPECT_RATIO_CUSTOM].value =
(float)custom->width / custom->height;
g_settings.video.aspect_ratio_idx = ASPECT_RATIO_CUSTOM;
rarch_main_command(RARCH_CMD_VIDEO_SET_ASPECT_RATIO);
return 0;
}
return -1;
}