/* RetroArch - A frontend for libretro.
* Copyright (C) 2010-2014 - Hans-Kristian Arntzen
* Copyright (C) 2011-2014 - Daniel De Matteis
*
* RetroArch is free software: you can redistribute it and/or modify it under the terms
* of the GNU General Public License as published by the Free Software Found-
* ation, either version 3 of the License, or (at your option) any later version.
*
* RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with RetroArch.
* If not, see .
*/
#include
#include
#include
#include
#include
#include
#include "menu_common_backend.h"
#include "../menu_navigation.h"
#include "../menu_input_line_cb.h"
#include "../../../gfx/gfx_common.h"
#include "../../../driver.h"
#include "../../../file_ext.h"
#include "../../../input/input_common.h"
#include "../../../config.def.h"
#include "../../../input/keyboard_line.h"
#include "../../../settings_data.h"
#ifdef HAVE_CONFIG_H
#include "../../../config.h"
#endif
#if defined(__CELLOS_LV2__)
#include
#if (CELL_SDK_VERSION > 0x340000)
#include
#endif
#endif
#ifdef HAVE_SHADER_MANAGER
static inline struct gfx_shader *shader_manager_get_current_shader(void *data, unsigned type)
{
menu_handle_t *menu = (menu_handle_t*)data;
struct gfx_shader *shader = NULL;
if (!menu)
{
RARCH_ERR("Cannot get current shader, menu handle is not initialized.\n");
return NULL;
}
if (type == MENU_SETTINGS_SHADER_PRESET_PARAMETERS)
shader = menu->shader;
if (!shader && driver.video_poke && driver.video_data && driver.video_poke->get_current_shader)
shader = driver.video_poke->get_current_shader(driver.video_data);
return shader;
}
#endif
static void menu_common_entries_init(void *data, unsigned menu_type)
{
unsigned i, last;
char tmp[256];
menu_handle_t *menu = (menu_handle_t*)data;
rarch_setting_t *setting_data, *current_setting;
setting_data = (rarch_setting_t *)setting_data_get_list();
if (!menu || !setting_data)
return;
switch (menu_type)
{
#ifdef HAVE_SHADER_MANAGER
case MENU_SETTINGS_SHADER_PARAMETERS:
case MENU_SETTINGS_SHADER_PRESET_PARAMETERS:
{
file_list_clear(menu->selection_buf);
struct gfx_shader *shader = shader_manager_get_current_shader(menu, menu_type);
if (shader)
for (i = 0; i < shader->num_parameters; i++)
file_list_push(menu->selection_buf, shader->parameters[i].desc, MENU_SETTINGS_SHADER_PARAMETER_0 + i, 0);
menu->parameter_shader = shader;
break;
}
case MENU_SETTINGS_SHADER_OPTIONS:
{
struct gfx_shader *shader = menu->shader;
if (!shader)
return;
file_list_clear(menu->selection_buf);
file_list_push(menu->selection_buf, "Apply Shader Changes",
MENU_SETTINGS_SHADER_APPLY, 0);
file_list_push(menu->selection_buf, "Default Filter", MENU_SETTINGS_SHADER_FILTER, 0);
file_list_push(menu->selection_buf, "Load Shader Preset",
MENU_SETTINGS_SHADER_PRESET, 0);
file_list_push(menu->selection_buf, "Save As Shader Preset",
MENU_SETTINGS_SHADER_PRESET_SAVE, 0);
file_list_push(menu->selection_buf, "Parameters (Current)",
MENU_SETTINGS_SHADER_PARAMETERS, 0);
file_list_push(menu->selection_buf, "Parameters (Menu)",
MENU_SETTINGS_SHADER_PRESET_PARAMETERS, 0);
file_list_push(menu->selection_buf, "Shader Passes",
MENU_SETTINGS_SHADER_PASSES, 0);
for (i = 0; i < shader->passes; i++)
{
char buf[64];
snprintf(buf, sizeof(buf), "Shader #%u", i);
file_list_push(menu->selection_buf, buf,
MENU_SETTINGS_SHADER_0 + 3 * i, 0);
snprintf(buf, sizeof(buf), "Shader #%u Filter", i);
file_list_push(menu->selection_buf, buf,
MENU_SETTINGS_SHADER_0_FILTER + 3 * i, 0);
snprintf(buf, sizeof(buf), "Shader #%u Scale", i);
file_list_push(menu->selection_buf, buf,
MENU_SETTINGS_SHADER_0_SCALE + 3 * i, 0);
}
}
break;
#endif
case MENU_SETTINGS_GENERAL_OPTIONS:
file_list_clear(menu->selection_buf);
file_list_push(menu->selection_buf, "Libretro Logging Level", MENU_SETTINGS_LIBRETRO_LOG_LEVEL, 0);
file_list_push(menu->selection_buf, "Logging Verbosity", MENU_SETTINGS_LOGGING_VERBOSITY, 0);
file_list_push(menu->selection_buf, "Performance Counters", MENU_SETTINGS_PERFORMANCE_COUNTERS_ENABLE, 0);
if ((current_setting = (rarch_setting_t*)setting_data_find_setting(setting_data, "game_history_size")))
{
*current_setting->value.unsigned_integer = g_settings.game_history_size;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_CONTENT_HISTORY_SIZE, 0);
}
if ((current_setting = (rarch_setting_t*)setting_data_find_setting(setting_data, "config_save_on_exit")))
{
*current_setting->value.boolean = g_extern.config_save_on_exit;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_CONFIG_SAVE_ON_EXIT, 0);
}
file_list_push(menu->selection_buf, "Configuration Per-Core", MENU_SETTINGS_PER_CORE_CONFIG, 0);
if ((current_setting = (rarch_setting_t*)setting_data_find_setting(setting_data, "video_gpu_screenshot")))
{
*current_setting->value.boolean = g_settings.video.gpu_screenshot;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_GPU_SCREENSHOT, 0);
}
file_list_push(menu->selection_buf, "Load Dummy On Core Shutdown", MENU_SETTINGS_LOAD_DUMMY_ON_CORE_SHUTDOWN, 0);
if ((current_setting = setting_data_find_setting(setting_data, "fps_show")))
{
*current_setting->value.boolean = g_settings.fps_show;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_DEBUG_TEXT, 0);
}
file_list_push(menu->selection_buf, "Maximum Run Speed", MENU_SETTINGS_FASTFORWARD_RATIO, 0);
file_list_push(menu->selection_buf, "Slow-Motion Ratio", MENU_SETTINGS_SLOWMOTION_RATIO, 0);
if ((current_setting = setting_data_find_setting(setting_data, "rewind_enable")))
{
*current_setting->value.boolean = g_settings.rewind_enable;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_REWIND_ENABLE, 0);
}
if ((current_setting = (rarch_setting_t*)setting_data_find_setting(setting_data, "rewind_granularity")))
{
*current_setting->value.unsigned_integer = g_settings.rewind_granularity;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_REWIND_GRANULARITY, 0);
}
if ((current_setting = setting_data_find_setting(setting_data, "block_sram_overwrite")))
{
*current_setting->value.boolean = g_settings.block_sram_overwrite;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_BLOCK_SRAM_OVERWRITE, 0);
}
if ((current_setting = setting_data_find_setting(setting_data, "autosave_interval")))
{
*current_setting->value.unsigned_integer = g_settings.autosave_interval;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_SRAM_AUTOSAVE, 0);
}
if ((current_setting = setting_data_find_setting(setting_data, "video_disable_composition")))
{
*current_setting->value.boolean = g_settings.video.disable_composition;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_WINDOW_COMPOSITING_ENABLE, 0);
}
if ((current_setting = (rarch_setting_t*)setting_data_find_setting(setting_data, "pause_nonactive")))
{
*current_setting->value.boolean = g_settings.pause_nonactive;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_PAUSE_IF_WINDOW_FOCUS_LOST, 0);
}
if ((current_setting = setting_data_find_setting(setting_data, "savestate_auto_save")))
{
*current_setting->value.boolean = g_settings.savestate_auto_save;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_SAVESTATE_AUTO_SAVE, 0);
}
if ((current_setting = setting_data_find_setting(setting_data, "savestate_auto_load")))
{
*current_setting->value.boolean = g_settings.savestate_auto_load;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_SAVESTATE_AUTO_LOAD, 0);
}
break;
case MENU_SETTINGS_VIDEO_OPTIONS:
file_list_clear(menu->selection_buf);
if ((current_setting = setting_data_find_setting(setting_data, "video_shared_context")))
{
*current_setting->value.boolean = g_settings.video.shared_context;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_VIDEO_HW_SHARED_CONTEXT, 0);
}
#if defined(GEKKO) || defined(__CELLOS_LV2__)
file_list_push(menu->selection_buf, "Screen Resolution", MENU_SETTINGS_VIDEO_RESOLUTION, 0);
#endif
file_list_push(menu->selection_buf, "Software Filter", MENU_SETTINGS_VIDEO_SOFTFILTER, 0);
#if defined(__CELLOS_LV2__)
file_list_push(menu->selection_buf, "PAL60 Mode", MENU_SETTINGS_VIDEO_PAL60, 0);
#endif
#ifndef HAVE_SHADER_MANAGER
file_list_push(menu->selection_buf, "Default Filter", MENU_SETTINGS_VIDEO_FILTER, 0);
#endif
#ifdef HW_RVL
file_list_push(menu->selection_buf, "VI Trap filtering", MENU_SETTINGS_VIDEO_SOFT_FILTER, 0);
#endif
#if defined(HW_RVL) || defined(_XBOX360)
file_list_push(menu->selection_buf, "Gamma", MENU_SETTINGS_VIDEO_GAMMA, 0);
#endif
#ifdef _XBOX1
file_list_push(menu->selection_buf, "Soft filtering", MENU_SETTINGS_SOFT_DISPLAY_FILTER, 0);
file_list_push(menu->selection_buf, "Flicker filtering", MENU_SETTINGS_FLICKER_FILTER, 0);
#endif
if ((current_setting = setting_data_find_setting(setting_data, "video_scale_integer")))
{
*current_setting->value.boolean = g_settings.video.scale_integer;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_VIDEO_INTEGER_SCALE, 0);
}
file_list_push(menu->selection_buf, "Aspect Ratio", MENU_SETTINGS_VIDEO_ASPECT_RATIO, 0);
file_list_push(menu->selection_buf, "Custom Ratio", MENU_SETTINGS_CUSTOM_VIEWPORT, 0);
if ((current_setting = setting_data_find_setting(setting_data, "video_fullscreen")))
{
*current_setting->value.boolean = g_settings.video.fullscreen;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_TOGGLE_FULLSCREEN, 0);
}
if ((current_setting = setting_data_find_setting(setting_data, "video_rotation")))
{
*current_setting->value.unsigned_integer = g_settings.video.rotation;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_VIDEO_ROTATION, 0);
}
if ((current_setting = setting_data_find_setting(setting_data, "video_vsync")))
{
*current_setting->value.boolean = g_settings.video.vsync;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_VIDEO_VSYNC, 0);
}
if ((current_setting = setting_data_find_setting(setting_data, "video_hard_sync")))
{
*current_setting->value.boolean = g_settings.video.hard_sync;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_VIDEO_HARD_SYNC, 0);
}
if ((current_setting = setting_data_find_setting(setting_data, "video_hard_sync_frames")))
{
*current_setting->value.unsigned_integer = g_settings.video.hard_sync_frames;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_VIDEO_HARD_SYNC_FRAMES, 0);
}
if ((current_setting = setting_data_find_setting(setting_data, "video_black_frame_insertion")))
{
*current_setting->value.boolean = g_settings.video.black_frame_insertion;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_VIDEO_BLACK_FRAME_INSERTION, 0);
}
if ((current_setting = setting_data_find_setting(setting_data, "video_swap_interval")))
{
*current_setting->value.unsigned_integer = g_settings.video.swap_interval;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_VIDEO_SWAP_INTERVAL, 0);
}
if ((current_setting = setting_data_find_setting(setting_data, "video_threaded")))
{
*current_setting->value.boolean = g_settings.video.threaded;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_VIDEO_THREADED, 0);
}
if ((current_setting = setting_data_find_setting(setting_data, "video_xscale")))
{
*current_setting->value.fraction = g_settings.video.xscale;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_VIDEO_WINDOW_SCALE_X, 0);
}
if ((current_setting = setting_data_find_setting(setting_data, "video_yscale")))
{
*current_setting->value.fraction = g_settings.video.yscale;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_VIDEO_WINDOW_SCALE_Y, 0);
}
if ((current_setting = setting_data_find_setting(setting_data, "video_crop_overscan")))
{
*current_setting->value.boolean = g_settings.video.crop_overscan;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_VIDEO_CROP_OVERSCAN, 0);
}
file_list_push(menu->selection_buf, "Monitor Index", MENU_SETTINGS_VIDEO_MONITOR_INDEX, 0);
file_list_push(menu->selection_buf, "Estimated Monitor FPS", MENU_SETTINGS_VIDEO_REFRESH_RATE_AUTO, 0);
break;
case MENU_SETTINGS_FONT_OPTIONS:
file_list_clear(menu->selection_buf);
if ((current_setting = (rarch_setting_t*)setting_data_find_setting(setting_data, "video_font_enable")))
{
*current_setting->value.boolean = g_settings.video.font_enable;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_FONT_ENABLE, 0);
}
if ((current_setting = (rarch_setting_t*)setting_data_find_setting(setting_data, "video_font_size")))
{
*current_setting->value.fraction = g_settings.video.font_size;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_FONT_SIZE, 0);
}
break;
case MENU_SETTINGS_CORE_OPTIONS:
file_list_clear(menu->selection_buf);
if (g_extern.system.core_options)
{
size_t i, opts;
opts = core_option_size(g_extern.system.core_options);
for (i = 0; i < opts; i++)
file_list_push(menu->selection_buf,
core_option_get_desc(g_extern.system.core_options, i), MENU_SETTINGS_CORE_OPTION_START + i, 0);
}
else
file_list_push(menu->selection_buf, "No options available.", MENU_SETTINGS_CORE_OPTION_NONE, 0);
break;
case MENU_SETTINGS_CORE_INFO:
{
core_info_t *info = menu->core_info_current;
file_list_clear(menu->selection_buf);
if (info->data)
{
snprintf(tmp, sizeof(tmp), "Core name: %s",
info->display_name ? info->display_name : "");
file_list_push(menu->selection_buf, tmp, MENU_SETTINGS_CORE_INFO_NONE, 0);
if (info->authors_list)
{
strlcpy(tmp, "Authors: ", sizeof(tmp));
string_list_join_concat(tmp, sizeof(tmp), info->authors_list, ", ");
file_list_push(menu->selection_buf, tmp, MENU_SETTINGS_CORE_INFO_NONE, 0);
}
if (info->permissions_list)
{
strlcpy(tmp, "Permissions: ", sizeof(tmp));
string_list_join_concat(tmp, sizeof(tmp), info->permissions_list, ", ");
file_list_push(menu->selection_buf, tmp, MENU_SETTINGS_CORE_INFO_NONE, 0);
}
if (info->supported_extensions_list)
{
strlcpy(tmp, "Supported extensions: ", sizeof(tmp));
string_list_join_concat(tmp, sizeof(tmp), info->supported_extensions_list, ", ");
file_list_push(menu->selection_buf, tmp, MENU_SETTINGS_CORE_INFO_NONE, 0);
}
if (info->firmware_count > 0)
{
core_info_list_update_missing_firmware(menu->core_info, info->path,
g_settings.system_directory);
file_list_push(menu->selection_buf, "Firmware: ", MENU_SETTINGS_CORE_INFO_NONE, 0);
for (i = 0; i < info->firmware_count; i++)
{
if (info->firmware[i].desc)
{
snprintf(tmp, sizeof(tmp), " name: %s",
info->firmware[i].desc ? info->firmware[i].desc : "");
file_list_push(menu->selection_buf, tmp, MENU_SETTINGS_CORE_INFO_NONE, 0);
snprintf(tmp, sizeof(tmp), " status: %s, %s",
info->firmware[i].missing ? "missing" : "present",
info->firmware[i].optional ? "optional" : "required");
file_list_push(menu->selection_buf, tmp, MENU_SETTINGS_CORE_INFO_NONE, 0);
}
}
}
if (info->notes)
{
snprintf(tmp, sizeof(tmp), "Core notes: ");
file_list_push(menu->selection_buf, tmp, MENU_SETTINGS_CORE_INFO_NONE, 0);
for (i = 0; i < info->note_list->size; i++)
{
snprintf(tmp, sizeof(tmp), " %s", info->note_list->elems[i].data);
file_list_push(menu->selection_buf, tmp, MENU_SETTINGS_CORE_INFO_NONE, 0);
}
}
}
else
file_list_push(menu->selection_buf, "No information available.", MENU_SETTINGS_CORE_OPTION_NONE, 0);
}
break;
case MENU_SETTINGS_OPTIONS:
file_list_clear(menu->selection_buf);
file_list_push(menu->selection_buf, "Driver Options", MENU_SETTINGS_DRIVERS, 0);
file_list_push(menu->selection_buf, "General Options", MENU_SETTINGS_GENERAL_OPTIONS, 0);
file_list_push(menu->selection_buf, "Video Options", MENU_SETTINGS_VIDEO_OPTIONS, 0);
#ifdef HAVE_SHADER_MANAGER
file_list_push(menu->selection_buf, "Shader Options", MENU_SETTINGS_SHADER_OPTIONS, 0);
#endif
file_list_push(menu->selection_buf, "Font Options", MENU_SETTINGS_FONT_OPTIONS, 0);
file_list_push(menu->selection_buf, "Audio Options", MENU_SETTINGS_AUDIO_OPTIONS, 0);
file_list_push(menu->selection_buf, "Input Options", MENU_SETTINGS_INPUT_OPTIONS, 0);
#ifdef HAVE_OVERLAY
file_list_push(menu->selection_buf, "Overlay Options", MENU_SETTINGS_OVERLAY_OPTIONS, 0);
#endif
#ifdef HAVE_NETPLAY
file_list_push(menu->selection_buf, "Netplay Options", MENU_SETTINGS_NETPLAY_OPTIONS, 0);
#endif
file_list_push(menu->selection_buf, "Path Options", MENU_SETTINGS_PATH_OPTIONS, 0);
if (g_extern.main_is_init && !g_extern.libretro_dummy)
{
if (g_extern.system.disk_control.get_num_images)
file_list_push(menu->selection_buf, "Disk Options", MENU_SETTINGS_DISK_OPTIONS, 0);
}
file_list_push(menu->selection_buf, "Privacy Options", MENU_SETTINGS_PRIVACY_OPTIONS, 0);
break;
case MENU_SETTINGS_PRIVACY_OPTIONS:
file_list_clear(menu->selection_buf);
#ifdef HAVE_CAMERA
if ((current_setting = (rarch_setting_t*)setting_data_find_setting(setting_data, "camera_allow")))
{
*current_setting->value.boolean = g_settings.camera.allow;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_PRIVACY_CAMERA_ALLOW, 0);
}
#endif
#ifdef HAVE_LOCATION
if ((current_setting = (rarch_setting_t*)setting_data_find_setting(setting_data, "location_allow")))
{
*current_setting->value.boolean = g_settings.location.allow;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_PRIVACY_LOCATION_ALLOW, 0);
}
#endif
break;
case MENU_SETTINGS_DISK_OPTIONS:
file_list_clear(menu->selection_buf);
file_list_push(menu->selection_buf, "Disk Index", MENU_SETTINGS_DISK_INDEX, 0);
file_list_push(menu->selection_buf, "Disk Image Append", MENU_SETTINGS_DISK_APPEND, 0);
break;
case MENU_SETTINGS_OVERLAY_OPTIONS:
file_list_clear(menu->selection_buf);
file_list_push(menu->selection_buf, "Overlay Enable", MENU_SETTINGS_OVERLAY_ENABLE, 0);
file_list_push(menu->selection_buf, "Overlay Preset", MENU_SETTINGS_OVERLAY_PRESET, 0);
if ((current_setting = (rarch_setting_t*)setting_data_find_setting(setting_data, "input_overlay_opacity")))
{
*current_setting->value.fraction = g_settings.input.overlay_opacity;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_OVERLAY_OPACITY, 0);
}
if ((current_setting = setting_data_find_setting(setting_data, "input_overlay_scale")))
{
*current_setting->value.fraction = g_settings.input.overlay_scale;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_OVERLAY_SCALE, 0);
}
break;
#ifdef HAVE_NETPLAY
case MENU_SETTINGS_NETPLAY_OPTIONS:
file_list_clear(menu->selection_buf);
if ((current_setting = (rarch_setting_t*)setting_data_find_setting(setting_data, "netplay_enable")))
{
*current_setting->value.boolean = g_extern.netplay_enable;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_NETPLAY_ENABLE, 0);
}
if ((current_setting = (rarch_setting_t*)setting_data_find_setting(setting_data, "netplay_mode")))
{
*current_setting->value.boolean = g_extern.netplay_is_client;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_NETPLAY_MODE, 0);
}
if ((current_setting = (rarch_setting_t*)setting_data_find_setting(setting_data, "netplay_spectator_mode_enable")))
{
*current_setting->value.boolean = g_extern.netplay_is_spectate;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_NETPLAY_SPECTATOR_MODE_ENABLE, 0);
}
file_list_push(menu->selection_buf, "Host IP Address", MENU_SETTINGS_NETPLAY_HOST_IP_ADDRESS, 0);
file_list_push(menu->selection_buf, "TCP/UDP Port", MENU_SETTINGS_NETPLAY_TCP_UDP_PORT, 0);
file_list_push(menu->selection_buf, "Delay Frames", MENU_SETTINGS_NETPLAY_DELAY_FRAMES, 0);
file_list_push(menu->selection_buf, "Nickname", MENU_SETTINGS_NETPLAY_NICKNAME, 0);
break;
#endif
case MENU_SETTINGS_PATH_OPTIONS:
file_list_clear(menu->selection_buf);
file_list_push(menu->selection_buf, "Browser Directory", MENU_BROWSER_DIR_PATH, 0);
file_list_push(menu->selection_buf, "Content Directory", MENU_CONTENT_DIR_PATH, 0);
file_list_push(menu->selection_buf, "Assets Directory", MENU_ASSETS_DIR_PATH, 0);
#ifdef HAVE_DYNAMIC
file_list_push(menu->selection_buf, "Config Directory", MENU_CONFIG_DIR_PATH, 0);
#endif
file_list_push(menu->selection_buf, "Core Directory", MENU_LIBRETRO_DIR_PATH, 0);
file_list_push(menu->selection_buf, "Core Info Directory", MENU_LIBRETRO_INFO_DIR_PATH, 0);
#ifdef HAVE_DYLIB
file_list_push(menu->selection_buf, "Software Filter Directory", MENU_FILTER_DIR_PATH, 0);
#endif
file_list_push(menu->selection_buf, "DSP Filter Directory", MENU_DSP_FILTER_DIR_PATH, 0);
#ifdef HAVE_SHADER_MANAGER
file_list_push(menu->selection_buf, "Shader Directory", MENU_SHADER_DIR_PATH, 0);
#endif
file_list_push(menu->selection_buf, "Savestate Directory", MENU_SAVESTATE_DIR_PATH, 0);
file_list_push(menu->selection_buf, "Savefile Directory", MENU_SAVEFILE_DIR_PATH, 0);
#ifdef HAVE_OVERLAY
file_list_push(menu->selection_buf, "Overlay Directory", MENU_OVERLAY_DIR_PATH, 0);
#endif
file_list_push(menu->selection_buf, "System Directory", MENU_SYSTEM_DIR_PATH, 0);
#ifdef HAVE_SCREENSHOTS
file_list_push(menu->selection_buf, "Screenshot Directory", MENU_SCREENSHOT_DIR_PATH, 0);
#endif
file_list_push(menu->selection_buf, "Autoconfig Directory", MENU_AUTOCONFIG_DIR_PATH, 0);
break;
case MENU_SETTINGS_INPUT_OPTIONS:
file_list_clear(menu->selection_buf);
file_list_push(menu->selection_buf, "Player", MENU_SETTINGS_BIND_PLAYER, 0);
file_list_push(menu->selection_buf, "Device", MENU_SETTINGS_BIND_DEVICE, 0);
file_list_push(menu->selection_buf, "Device Type", MENU_SETTINGS_BIND_DEVICE_TYPE, 0);
file_list_push(menu->selection_buf, "Analog D-pad Mode", MENU_SETTINGS_BIND_ANALOG_MODE, 0);
file_list_push(menu->selection_buf, "Input Axis Threshold", MENU_SETTINGS_INPUT_AXIS_THRESHOLD, 0);
file_list_push(menu->selection_buf, "Autodetect Enable", MENU_SETTINGS_DEVICE_AUTODETECT_ENABLE, 0);
file_list_push(menu->selection_buf, "Bind Mode", MENU_SETTINGS_CUSTOM_BIND_MODE, 0);
file_list_push(menu->selection_buf, "Configure All (RetroPad)", MENU_SETTINGS_CUSTOM_BIND_ALL, 0);
file_list_push(menu->selection_buf, "Default All (RetroPad)", MENU_SETTINGS_CUSTOM_BIND_DEFAULT_ALL, 0);
#ifdef HAVE_OSK
file_list_push(menu->selection_buf, "Onscreen Keyboard Enable", MENU_SETTINGS_ONSCREEN_KEYBOARD_ENABLE, 0);
#endif
last = (driver.input && driver.input->set_keybinds && !driver.input->get_joypad_driver) ? (MENU_SETTINGS_BIND_BEGIN + RETRO_DEVICE_ID_JOYPAD_R3) : MENU_SETTINGS_BIND_ALL_LAST;
for (i = MENU_SETTINGS_BIND_BEGIN; i <= last; i++)
file_list_push(menu->selection_buf, input_config_bind_map[i - MENU_SETTINGS_BIND_BEGIN].desc, i, 0);
break;
case MENU_SETTINGS_AUDIO_OPTIONS:
file_list_clear(menu->selection_buf);
file_list_push(menu->selection_buf, "DSP Filter", MENU_SETTINGS_AUDIO_DSP_FILTER, 0);
if ((current_setting = (rarch_setting_t*)setting_data_find_setting(setting_data, "audio_mute")))
{
*current_setting->value.boolean = g_extern.audio_data.mute;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_AUDIO_MUTE, 0);
}
if ((current_setting = (rarch_setting_t*)setting_data_find_setting(setting_data, "audio_latency")))
{
*current_setting->value.unsigned_integer = g_settings.audio.latency;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_AUDIO_LATENCY, 0);
}
if ((current_setting = (rarch_setting_t*)setting_data_find_setting(setting_data, "audio_sync")))
{
*current_setting->value.boolean = g_settings.audio.sync;
file_list_push(menu->selection_buf, current_setting->short_description, MENU_SETTINGS_AUDIO_SYNC, 0);
}
file_list_push(menu->selection_buf, "Rate Control Delta", MENU_SETTINGS_AUDIO_CONTROL_RATE_DELTA, 0);
#ifdef __CELLOS_LV2__
file_list_push(menu->selection_buf, "System BGM Control", MENU_SETTINGS_CUSTOM_BGM_CONTROL_ENABLE, 0);
#endif
file_list_push(menu->selection_buf, "Volume Level", MENU_SETTINGS_AUDIO_VOLUME, 0);
break;
case MENU_SETTINGS_DRIVERS:
file_list_clear(menu->selection_buf);
file_list_push(menu->selection_buf, "Video Driver", MENU_SETTINGS_DRIVER_VIDEO, 0);
file_list_push(menu->selection_buf, "Audio Driver", MENU_SETTINGS_DRIVER_AUDIO, 0);
file_list_push(menu->selection_buf, "Audio Device", MENU_SETTINGS_DRIVER_AUDIO_DEVICE, 0);
file_list_push(menu->selection_buf, "Audio Resampler", MENU_SETTINGS_DRIVER_AUDIO_RESAMPLER, 0);
file_list_push(menu->selection_buf, "Input Driver", MENU_SETTINGS_DRIVER_INPUT, 0);
#ifdef HAVE_CAMERA
file_list_push(menu->selection_buf, "Camera Driver", MENU_SETTINGS_DRIVER_CAMERA, 0);
#endif
#ifdef HAVE_LOCATION
file_list_push(menu->selection_buf, "Location Driver", MENU_SETTINGS_DRIVER_LOCATION, 0);
#endif
#ifdef HAVE_MENU
file_list_push(menu->selection_buf, "Menu Driver", MENU_SETTINGS_DRIVER_MENU, 0);
#endif
break;
case MENU_SETTINGS_PERFORMANCE_COUNTERS:
file_list_clear(menu->selection_buf);
file_list_push(menu->selection_buf, "Frontend Counters", MENU_SETTINGS_PERFORMANCE_COUNTERS_FRONTEND, 0);
file_list_push(menu->selection_buf, "Core Counters", MENU_SETTINGS_PERFORMANCE_COUNTERS_LIBRETRO, 0);
break;
case MENU_SETTINGS_PERFORMANCE_COUNTERS_LIBRETRO:
file_list_clear(menu->selection_buf);
{
const struct retro_perf_counter **counters = (const struct retro_perf_counter**)perf_counters_libretro;
unsigned num = perf_ptr_libretro;
if (!counters || num == 0)
break;
for (i = 0; i < num; i++)
if (counters[i] && counters[i]->ident)
file_list_push(menu->selection_buf, counters[i]->ident, MENU_SETTINGS_LIBRETRO_PERF_COUNTERS_BEGIN + i, 0);
}
break;
case MENU_SETTINGS_PERFORMANCE_COUNTERS_FRONTEND:
file_list_clear(menu->selection_buf);
{
const struct retro_perf_counter **counters = (const struct retro_perf_counter**)perf_counters_rarch;
unsigned num = perf_ptr_rarch;
if (!counters || num == 0)
break;
for (i = 0; i < num; i++)
if (counters[i] && counters[i]->ident)
file_list_push(menu->selection_buf, counters[i]->ident, MENU_SETTINGS_PERF_COUNTERS_BEGIN + i, 0);
}
break;
case MENU_SETTINGS:
file_list_clear(menu->selection_buf);
#if defined(HAVE_DYNAMIC) || defined(HAVE_LIBRETRO_MANAGEMENT)
file_list_push(menu->selection_buf, "Core", MENU_SETTINGS_CORE, 0);
#endif
if (menu->history)
file_list_push(menu->selection_buf, "Load Content (History)", MENU_SETTINGS_OPEN_HISTORY, 0);
if (menu->core_info && core_info_list_num_info_files(menu->core_info))
file_list_push(menu->selection_buf, "Load Content (Detect Core)", MENU_SETTINGS_OPEN_FILEBROWSER_DEFERRED_CORE, 0);
if (menu->info.library_name || g_extern.system.info.library_name)
{
char load_game_core_msg[64];
snprintf(load_game_core_msg, sizeof(load_game_core_msg), "Load Content (%s)",
menu->info.library_name ? menu->info.library_name : g_extern.system.info.library_name);
file_list_push(menu->selection_buf, load_game_core_msg, MENU_SETTINGS_OPEN_FILEBROWSER, 0);
}
file_list_push(menu->selection_buf, "Core Options", MENU_SETTINGS_CORE_OPTIONS, 0);
file_list_push(menu->selection_buf, "Core Information", MENU_SETTINGS_CORE_INFO, 0);
file_list_push(menu->selection_buf, "Settings", MENU_SETTINGS_OPTIONS, 0);
if (g_extern.perfcnt_enable)
file_list_push(menu->selection_buf, "Performance Counters", MENU_SETTINGS_PERFORMANCE_COUNTERS, 0);
if (g_extern.main_is_init && !g_extern.libretro_dummy)
{
file_list_push(menu->selection_buf, "Save State", MENU_SETTINGS_SAVESTATE_SAVE, 0);
file_list_push(menu->selection_buf, "Load State", MENU_SETTINGS_SAVESTATE_LOAD, 0);
#ifdef HAVE_SCREENSHOTS
file_list_push(menu->selection_buf, "Take Screenshot", MENU_SETTINGS_SCREENSHOT, 0);
#endif
file_list_push(menu->selection_buf, "Resume Content", MENU_SETTINGS_RESUME_GAME, 0);
file_list_push(menu->selection_buf, "Restart Content", MENU_SETTINGS_RESTART_GAME, 0);
}
#ifndef HAVE_DYNAMIC
file_list_push(menu->selection_buf, "Restart RetroArch", MENU_SETTINGS_RESTART_EMULATOR, 0);
#endif
file_list_push(menu->selection_buf, "RetroArch Config", MENU_SETTINGS_CONFIG, 0);
file_list_push(menu->selection_buf, "Save New Config", MENU_SETTINGS_SAVE_CONFIG, 0);
file_list_push(menu->selection_buf, "Help", MENU_START_SCREEN, 0);
file_list_push(menu->selection_buf, "Quit RetroArch", MENU_SETTINGS_QUIT_RARCH, 0);
break;
}
if (driver.menu_ctx && driver.menu_ctx->populate_entries)
driver.menu_ctx->populate_entries(menu, menu_type);
}
static int menu_info_screen_iterate(unsigned action)
{
char msg[1024];
if (!driver.menu)
return 0;
if (driver.video_data && driver.menu_ctx && driver.menu_ctx->render)
driver.menu_ctx->render();
switch (driver.menu->info_selection)
{
case MENU_SETTINGS_WINDOW_COMPOSITING_ENABLE:
snprintf(msg, sizeof(msg),
"-- Forcibly disable composition.\n"
"Only valid on Windows Vista/7 for now.");
break;
case MENU_SETTINGS_LIBRETRO_LOG_LEVEL:
snprintf(msg, sizeof(msg),
"-- Sets log level for libretro cores \n"
"(GET_LOG_INTERFACE). \n"
" \n"
" If a log level issued by a libretro \n"
" core is below libretro_log level, it \n"
" is ignored.\n"
" \n"
" DEBUG logs are always ignored unless \n"
" verbose mode is activated (--verbose).\n"
" \n"
" DEBUG = 0\n"
" INFO = 1\n"
" WARN = 2\n"
" ERROR = 3"
);
break;
case MENU_SETTINGS_LOGGING_VERBOSITY:
snprintf(msg, sizeof(msg),
"-- Enable or disable verbosity level \n"
"of frontend.");
break;
case MENU_SETTINGS_PERFORMANCE_COUNTERS_ENABLE:
snprintf(msg, sizeof(msg),
"-- Enable or disable frontend \n"
"performance counters.");
break;
case MENU_SYSTEM_DIR_PATH:
snprintf(msg, sizeof(msg),
"-- System Directory. \n"
" \n"
"Sets the 'system' directory.\n"
"Implementations can query for this\n"
"directory to load BIOSes, \n"
"system-specific configs, etc.");
break;
case MENU_START_SCREEN:
snprintf(msg, sizeof(msg),
" -- Show startup screen in menu.\n"
"Is automatically set to false when seen\n"
"for the first time.\n"
" \n"
"This is only updated in config if\n"
"'Config Save On Exit' is set to true.\n");
break;
case MENU_SETTINGS_CONFIG_SAVE_ON_EXIT:
snprintf(msg, sizeof(msg),
" -- Flushes config to disk on exit.\n"
"Useful for menu as settings can be\n"
"modified. Overwrites the config.\n"
" \n"
"#include's and comments are not \n"
"preserved. \n"
" \n"
"By design, the config file is \n"
"considered immutable as it is \n"
"likely maintained by the user, \n"
"and should not be overwritten \n"
"behind the user's back."
#if defined(RARCH_CONSOLE) || defined(RARCH_MOBILE)
"\nThis is not not the case on \n"
"consoles however, where \n"
"looking at the config file \n"
"manually isn't really an option."
#endif
);
break;
case MENU_SETTINGS_OPEN_FILEBROWSER:
snprintf(msg, sizeof(msg),
" -- Load Content. \n"
"Browse for content. \n"
" \n"
"To load content, you need a \n"
"libretro core to use, and a \n"
"content file. \n"
" \n"
"To control where the menu starts \n"
" to browse for content, set \n"
"Browser Directory. If not set, \n"
"it will start in root. \n"
" \n"
"The browser will filter out \n"
"extensions for the last core set \n"
"in 'Core', and use that core when \n"
"content is loaded."
);
break;
case MENU_SETTINGS_PER_CORE_CONFIG:
snprintf(msg, sizeof(msg),
" -- Load up a specific config file \n"
"based on the core being used.\n");
break;
case MENU_SETTINGS_VIDEO_WINDOW_SCALE_X:
case MENU_SETTINGS_VIDEO_WINDOW_SCALE_Y:
snprintf(msg, sizeof(msg),
" -- Fullscreen resolution.\n"
" \n"
"Resolution of 0 uses the \n"
"resolution of the environment.\n");
break;
case MENU_SETTINGS_VIDEO_VSYNC:
snprintf(msg, sizeof(msg),
" -- Video V-Sync.\n");
break;
case MENU_SETTINGS_VIDEO_HARD_SYNC:
snprintf(msg, sizeof(msg),
" -- Attempts to hard-synchronize \n"
"CPU and GPU.\n"
" \n"
"Can reduce latency at cost of \n"
"performance.");
break;
case MENU_SETTINGS_VIDEO_HARD_SYNC_FRAMES:
snprintf(msg, sizeof(msg),
" -- Sets how many frames CPU can \n"
"run ahead of GPU when using 'GPU \n"
"Hard Sync'.\n"
" \n"
"Maximum is 3.\n"
" \n"
" 0: Syncs to GPU immediately.\n"
" 1: Syncs to previous frame.\n"
" 2: Etc ...");
break;
case MENU_SETTINGS_VIDEO_BLACK_FRAME_INSERTION:
snprintf(msg, sizeof(msg),
" -- Inserts a black frame inbetween \n"
"frames.\n"
" \n"
"Useful for 120 Hz monitors who want to \n"
"play 60 Hz material with eliminated \n"
"ghosting.\n"
" \n"
"Video refresh rate should still be \n"
"configured as if it is a 60 Hz monitor \n"
"(divide refresh rate by 2).");
break;
case MENU_SETTINGS_VIDEO_THREADED:
snprintf(msg, sizeof(msg),
" -- Use threaded video driver.\n"
" \n"
"Using this might improve performance at \n"
"possible cost of latency and more video \n"
"stuttering.");
break;
case MENU_SETTINGS_VIDEO_INTEGER_SCALE:
snprintf(msg, sizeof(msg),
" -- Only scales video in integer \n"
"steps.\n"
" \n"
"The base size depends on system-reported \n"
"geometry and aspect ratio.\n"
" \n"
"If Force Aspect is not set, X/Y will be \n"
"integer scaled independently.");
break;
case MENU_SETTINGS_VIDEO_CROP_OVERSCAN:
snprintf(msg, sizeof(msg),
" -- Forces cropping of overscanned \n"
"frames.\n"
" \n"
"Exact behavior of this option is \n"
"core-implementation specific.");
break;
case MENU_SETTINGS_VIDEO_MONITOR_INDEX:
snprintf(msg, sizeof(msg),
" -- Which monitor to prefer.\n"
" \n"
"0 (default) means no particular monitor \n"
"is preferred, 1 and up (1 being first \n"
"monitor), suggests RetroArch to use that \n"
"particular monitor.");
break;
case MENU_SETTINGS_VIDEO_ROTATION:
snprintf(msg, sizeof(msg),
" -- Forces a certain rotation \n"
"of the screen.\n"
" \n"
"The rotation is added to rotations which\n"
"the libretro core sets (see Video Allow\n"
"Rotate).");
break;
case MENU_SETTINGS_AUDIO_CONTROL_RATE_DELTA:
snprintf(msg, sizeof(msg),
" -- Audio rate control.\n"
" \n"
"Setting this to 0 disables rate control.\n"
"Any other value controls audio rate control \n"
"delta.\n"
" \n"
"Defines how much input rate can be adjusted \n"
"dynamically.\n"
" \n"
" Input rate is defined as: \n"
" input rate * (1.0 +/- (rate control delta))");
break;
case MENU_SETTINGS_AUDIO_VOLUME:
snprintf(msg, sizeof(msg),
" -- Audio volume, expressed in dB.\n"
" \n"
" 0 dB is normal volume. No gain will be applied.\n"
"Gain can be controlled in runtime with Input\n"
"Volume Up / Input Volume Down.");
break;
case MENU_SETTINGS_VIDEO_SOFTFILTER:
#ifdef HAVE_FILTERS_BUILTIN
snprintf(msg, sizeof(msg),
" -- CPU-based video filter.");
#else
snprintf(msg, sizeof(msg),
" -- CPU-based video filter.\n"
" \n"
"Path to a dynamic library.");
#endif
break;
case MENU_SETTINGS_BLOCK_SRAM_OVERWRITE:
snprintf(msg, sizeof(msg),
" -- Block SRAM from being overwritten \n"
"when loading save states.\n"
" \n"
"Might potentially lead to buggy games.");
break;
case MENU_SETTINGS_PRIVACY_CAMERA_ALLOW:
snprintf(msg, sizeof(msg),
" -- Allow or disallow camera access by \n"
"cores.");
break;
case MENU_SETTINGS_PRIVACY_LOCATION_ALLOW:
snprintf(msg, sizeof(msg),
" -- Allow or disallow location services \n"
"access by cores.");
break;
case MENU_SETTINGS_REWIND_ENABLE:
snprintf(msg, sizeof(msg),
" -- Enable rewinding.\n"
" \n"
"This will take a performance hit, \n"
"so it is disabled by default.");
break;
case MENU_SETTINGS_REWIND_GRANULARITY:
snprintf(msg, sizeof(msg),
" -- Rewind granularity.\n"
" \n"
" When rewinding defined number of \n"
"frames, you can rewind several frames \n"
"at a time, increasing the rewinding \n"
"speed.");
break;
case MENU_SETTINGS_DEVICE_AUTODETECT_ENABLE:
snprintf(msg, sizeof(msg),
" -- Enable input auto-detection.\n"
" \n"
"Will attempt to auto-configure \n"
"joypads, Plug-and-Play style.");
break;
case MENU_SETTINGS_INPUT_AXIS_THRESHOLD:
snprintf(msg, sizeof(msg),
" -- Defines axis threshold.\n"
" \n"
" Possible values are [0.0, 1.0].");
break;
case MENU_SETTINGS_CORE:
snprintf(msg, sizeof(msg),
" -- Core Selection. \n"
" \n"
"Browse for a libretro core \n"
"implementation. Where the browser \n"
"starts depends on your Core Directory \n"
"path. If blank, it will start in root. \n"
" \n"
"If Core Directory is a directory, the menu \n"
"will use that as top folder. If Core \n"
"Directory is a full path, it will start \n"
"in the folder where the file is.");
break;
case MENU_SETTINGS_OPEN_HISTORY:
snprintf(msg, sizeof(msg),
" -- Loading content from history. \n"
" \n"
"As content is loaded, content and libretro \n"
"core combinations are saved to history. \n"
" \n"
"The history is saved to a file in the same \n"
"directory as the RetroArch config file. If \n"
"no config file was loaded in startup, history \n"
"will not be saved or loaded, and will not exist \n"
"in the main menu."
);
break;
case MENU_SETTINGS_SHADER_PRESET:
snprintf(msg, sizeof(msg),
" -- Load Shader Preset. \n"
" \n"
" Load a "
#ifdef HAVE_CG
"Cg"
#endif
#ifdef HAVE_GLSL
#ifdef HAVE_CG
"/"
#endif
"GLSL"
#endif
#ifdef HAVE_HLSL
#if defined(HAVE_CG) || defined(HAVE_HLSL)
"/"
#endif
"HLSL"
#endif
" preset directly. \n"
"The menu shader menu is updated accordingly. \n"
" \n"
"If the CGP uses scaling methods which are not \n"
"simple, (i.e. source scaling, same scaling \n"
"factor for X/Y), the scaling factor displayed \n"
"in the menu might not be correct."
);
break;
case MENU_SETTINGS_SHADER_APPLY:
snprintf(msg, sizeof(msg),
" -- Apply Shader Changes. \n"
" \n"
"After changing shader settings, use this to \n"
"apply changes. \n"
" \n"
"Changing shader settings is a somewhat \n"
"expensive operation so it has to be \n"
"done explicitly. \n"
" \n"
"When you apply shaders, the menu shader \n"
"settings are saved to a temporary file (either \n"
"menu.cgp or menu.glslp) and loaded. The file \n"
"persists after RetroArch exits. The file is \n"
"saved to Shader Directory."
);
break;
case MENU_SETTINGS_SHADER_PASSES:
snprintf(msg, sizeof(msg),
" -- Shader Passes. \n"
" \n"
"RetroArch allows you to mix and match various \n"
"shaders with arbitrary shader passes, with \n"
"custom hardware filters and scale factors. \n"
" \n"
"This option specifies the number of shader \n"
"passes to use. If you set this to 0, and use \n"
"Apply Shader Changes, you use a 'blank' shader. \n"
" \n"
"The Default Filter option will affect the \n"
"stretching filter.");
break;
case MENU_SETTINGS_BIND_DEVICE:
snprintf(msg, sizeof(msg),
" -- Input Device. \n"
" \n"
"Picks which gamepad to use for player N. \n"
"The name of the pad is available."
);
break;
case MENU_SETTINGS_BIND_DEVICE_TYPE:
snprintf(msg, sizeof(msg),
" -- Input Device Type. \n"
" \n"
"Picks which device type to use. This is \n"
"relevant for the libretro core itself."
);
break;
case MENU_SETTINGS_DRIVER_INPUT:
if (!strcmp(g_settings.input.driver, "udev"))
snprintf(msg, sizeof(msg),
" -- udev Input driver. \n"
" \n"
"This driver can run without X. \n"
" \n"
"It uses the recent evdev joypad API \n"
"for joystick support. It supports \n"
"hotplugging and force feedback (if \n"
"supported by device). \n"
" \n"
"The driver reads evdev events for keyboard \n"
"support. It also supports keyboard callback, \n"
"mice and touchpads. \n"
" \n"
"By default in most distros, /dev/input nodes \n"
"are root-only (mode 600). You can set up a udev \n"
"rule which makes these accessible to non-root."
);
else if (!strcmp(g_settings.input.driver, "linuxraw"))
snprintf(msg, sizeof(msg),
" -- linuxraw Input driver. \n"
" \n"
"This driver requires an active TTY. Keyboard \n"
"events are read directly from the TTY which \n"
"makes it simpler, but not as flexible as udev. \n"
"Mice, etc, are not supported at all. \n"
" \n"
"This driver uses the older joystick API \n"
"(/dev/input/js*).");
else
snprintf(msg, sizeof(msg),
" -- Input driver.\n"
" \n"
"Depending on video driver, it might \n"
"force a different input driver.");
break;
case MENU_SETTINGS_AUDIO_DSP_FILTER:
snprintf(msg, sizeof(msg),
" -- Audio DSP plugin.\n"
" Processes audio before it's sent to \n"
"the driver."
#ifndef HAVE_FILTERS_BUILTIN
" \n"
"Path to a dynamic library."
#endif
);
break;
case MENU_SETTINGS_TOGGLE_FULLSCREEN:
snprintf(msg, sizeof(msg),
" -- Toggles fullscreen.");
break;
case MENU_SETTINGS_SLOWMOTION_RATIO:
snprintf(msg, sizeof(msg),
" -- Slowmotion ratio."
" \n"
"When slowmotion, content will slow\n"
"down by factor.");
break;
case MENU_SETTINGS_FASTFORWARD_RATIO:
snprintf(msg, sizeof(msg),
" -- Fastforward ratio."
" \n"
"The maximum rate at which content will\n"
"be run when using fast forward.\n"
" \n"
" (E.g. 5.0 for 60 fps content => 300 fps \n"
"cap).\n"
" \n"
"RetroArch will go to sleep to ensure that \n"
"the maximum rate will not be exceeded.\n"
"Do not rely on this cap to be perfectly \n"
"accurate.");
break;
case MENU_SETTINGS_PAUSE_IF_WINDOW_FOCUS_LOST:
snprintf(msg, sizeof(msg),
" -- Pause gameplay when window focus \n"
"is lost.");
break;
case MENU_SETTINGS_GPU_SCREENSHOT:
snprintf(msg, sizeof(msg),
" -- Screenshots output of GPU shaded \n"
"material if available.");
break;
case MENU_SETTINGS_SRAM_AUTOSAVE:
snprintf(msg, sizeof(msg),
" -- Autosaves the non-volatile SRAM \n"
"at a regular interval.\n"
" \n"
"This is disabled by default unless set \n"
"otherwise. The interval is measured in \n"
"seconds. \n"
" \n"
"A value of 0 disables autosave.");
break;
case MENU_SCREENSHOT_DIR_PATH:
snprintf(msg, sizeof(msg),
" -- Screenshot Directory. \n"
" \n"
"Directory to dump screenshots to."
);
break;
case MENU_SETTINGS_DRIVER_AUDIO_DEVICE:
snprintf(msg, sizeof(msg),
" -- Override the default audio device \n"
"the audio driver uses.\n"
"This is driver dependent. E.g.\n"
#ifdef HAVE_ALSA
" \n"
"ALSA wants a PCM device."
#endif
#ifdef HAVE_OSS
" \n"
"OSS wants a path (e.g. /dev/dsp)."
#endif
#ifdef HAVE_JACK
" \n"
"JACK wants portnames (e.g. system:playback1\n"
",system:playback_2)."
#endif
#ifdef HAVE_RSOUND
" \n"
"RSound wants an IP address to an RSound \n"
"server."
#endif
);
break;
case MENU_ASSETS_DIR_PATH:
snprintf(msg, sizeof(msg),
" -- Assets Directory. \n"
" \n"
" This location is queried by default when \n"
"menu interfaces try to look for loadable \n"
"assets, etc.");
break;
case MENU_SETTINGS_SAVESTATE_AUTO_SAVE:
snprintf(msg, sizeof(msg),
" -- Automatically saves a savestate at the \n"
"end of RetroArch's lifetime.\n"
" \n"
"RetroArch will automatically load any savestate\n"
"with this path on startup if 'Savestate Auto\n"
"Load' is set.");
break;
case MENU_SETTINGS_VIDEO_SWAP_INTERVAL:
snprintf(msg, sizeof(msg),
" -- VSync Swap Interval.\n"
" \n"
"Uses a custom swap interval for VSync. Set this \n"
"to effectively halve monitor refresh rate.");
break;
case MENU_SETTINGS_VIDEO_REFRESH_RATE_AUTO:
snprintf(msg, sizeof(msg),
" -- Refresh Rate Auto.\n"
" \n"
"The accurate refresh rate of our monitor (Hz).\n"
"This is used to calculate audio input rate with \n"
"the formula: \n"
" \n"
"audio_input_rate = game input rate * display \n"
"refresh rate / game refresh rate\n"
" \n"
"If the implementation does not report any \n"
"values, NTSC defaults will be assumed for \n"
"compatibility.\n"
" \n"
"This value should stay close to 60Hz to avoid \n"
"large pitch changes. If your monitor does \n"
"not run at 60Hz, or something close to it, \n"
"disable VSync, and leave this at its default.");
break;
case MENU_LIBRETRO_DIR_PATH:
snprintf(msg, sizeof(msg),
" -- Core Directory. \n"
" \n"
"A directory for where to search for \n"
"libretro core implementations.");
break;
case MENU_SAVEFILE_DIR_PATH:
snprintf(msg, sizeof(msg),
" -- Savefile Directory. \n"
" \n"
"Save all save files (*.srm) to this \n"
"directory. This includes related files like \n"
".bsv, .rt, .psrm, etc...\n"
" \n"
"This will be overridden by explicit command line\n"
"options.");
break;
case MENU_SAVESTATE_DIR_PATH:
snprintf(msg, sizeof(msg),
" -- Savestate Directory. \n"
" \n"
"Save all save states (*.state) to this \n"
"directory.\n"
" \n"
"This will be overridden by explicit command line\n"
"options.");
break;
case MENU_SETTINGS_BIND_BEGIN + RARCH_ANALOG_LEFT_X_PLUS:
case MENU_SETTINGS_BIND_BEGIN + RARCH_ANALOG_LEFT_X_MINUS:
case MENU_SETTINGS_BIND_BEGIN + RARCH_ANALOG_LEFT_Y_PLUS:
case MENU_SETTINGS_BIND_BEGIN + RARCH_ANALOG_LEFT_Y_MINUS:
case MENU_SETTINGS_BIND_BEGIN + RARCH_ANALOG_RIGHT_X_PLUS:
case MENU_SETTINGS_BIND_BEGIN + RARCH_ANALOG_RIGHT_X_MINUS:
case MENU_SETTINGS_BIND_BEGIN + RARCH_ANALOG_RIGHT_Y_PLUS:
case MENU_SETTINGS_BIND_BEGIN + RARCH_ANALOG_RIGHT_Y_MINUS:
snprintf(msg, sizeof(msg),
" -- Axis for analog stick (DualShock-esque).\n"
" \n"
"Bound as usual, however, if a real analog \n"
"axis is bound, it can be read as a true analog.\n"
" \n"
"Positive X axis is right. \n"
"Positive Y axis is down.");
break;
case MENU_SETTINGS_BIND_BEGIN + RARCH_SHADER_NEXT:
snprintf(msg, sizeof(msg),
" -- Applies next shader in directory.");
break;
case MENU_SETTINGS_BIND_BEGIN + RARCH_SHADER_PREV:
snprintf(msg, sizeof(msg),
" -- Applies previous shader in directory.");
break;
case MENU_SETTINGS_BIND_BEGIN + RARCH_LOAD_STATE_KEY:
snprintf(msg, sizeof(msg),
" -- Loads state.");
break;
case MENU_SETTINGS_BIND_BEGIN + RARCH_SAVE_STATE_KEY:
snprintf(msg, sizeof(msg),
" -- Saves state.");
break;
case MENU_SETTINGS_BIND_BEGIN + RARCH_STATE_SLOT_PLUS:
case MENU_SETTINGS_BIND_BEGIN + RARCH_STATE_SLOT_MINUS:
snprintf(msg, sizeof(msg),
" -- State slots.\n"
" \n"
" With slot set to 0, save state name is *.state \n"
" (or whatever defined on commandline).\n"
"When slot is != 0, path will be (path)(d), \n"
"where (d) is slot number.");
break;
case MENU_SETTINGS_BIND_BEGIN + RARCH_TURBO_ENABLE:
snprintf(msg, sizeof(msg),
" -- Turbo enable.\n"
" \n"
"Holding the turbo while pressing another \n"
"button will let the button enter a turbo \n"
"mode where the button state is modulated \n"
"with a periodic signal. \n"
" \n"
"The modulation stops when the button \n"
"itself (not turbo button) is released.");
break;
case MENU_SETTINGS_BIND_BEGIN + RARCH_FAST_FORWARD_HOLD_KEY:
snprintf(msg, sizeof(msg),
" -- Hold for fast-forward. Releasing button \n"
"disables fast-forward.");
break;
case MENU_SETTINGS_BIND_BEGIN + RARCH_QUIT_KEY:
snprintf(msg, sizeof(msg),
" -- Key to exit RetroArch cleanly."
#if !defined(RARCH_MOBILE) && !defined(RARCH_CONSOLE)
"\nKilling it in any hard way (SIGKILL, \n"
"etc) will terminate without saving\n"
"RAM, etc. On Unix-likes,\n"
"SIGINT/SIGTERM allows\n"
"a clean deinitialization."
#endif
);
break;
case MENU_SETTINGS_BIND_BEGIN + RARCH_REWIND:
snprintf(msg, sizeof(msg),
" -- Hold button down to rewind.\n"
" \n"
"Rewind must be enabled.");
break;
case MENU_SETTINGS_BIND_BEGIN + RARCH_MOVIE_RECORD_TOGGLE:
snprintf(msg, sizeof(msg),
" -- Toggle between recording and not.");
break;
case MENU_SETTINGS_BIND_BEGIN + RARCH_PAUSE_TOGGLE:
snprintf(msg, sizeof(msg),
" -- Toggle between paused and non-paused state.");
break;
case MENU_SETTINGS_BIND_BEGIN + RARCH_FRAMEADVANCE:
snprintf(msg, sizeof(msg),
" -- Frame advance when content is paused.");
break;
case MENU_SETTINGS_BIND_BEGIN + RARCH_RESET:
snprintf(msg, sizeof(msg),
" -- Reset the content.\n");
break;
case MENU_SETTINGS_BIND_BEGIN + RARCH_CHEAT_INDEX_PLUS:
snprintf(msg, sizeof(msg),
" -- Increment cheat index.\n");
break;
case MENU_SETTINGS_BIND_BEGIN + RARCH_CHEAT_INDEX_MINUS:
snprintf(msg, sizeof(msg),
" -- Decrement cheat index.\n");
break;
case MENU_SETTINGS_BIND_BEGIN + RARCH_CHEAT_TOGGLE:
snprintf(msg, sizeof(msg),
" -- Toggle cheat index.\n");
break;
case MENU_SETTINGS_BIND_BEGIN + RARCH_SCREENSHOT:
snprintf(msg, sizeof(msg),
" -- Take screenshot.");
break;
case MENU_SETTINGS_BIND_BEGIN + RARCH_MUTE:
snprintf(msg, sizeof(msg),
" -- Mute/unmute audio.");
break;
case MENU_SETTINGS_BIND_BEGIN + RARCH_NETPLAY_FLIP:
snprintf(msg, sizeof(msg),
" -- Netplay flip players.");
break;
case MENU_SETTINGS_BIND_BEGIN + RARCH_SLOWMOTION:
snprintf(msg, sizeof(msg),
" -- Hold for slowmotion.");
break;
case MENU_SETTINGS_BIND_BEGIN + RARCH_ENABLE_HOTKEY:
snprintf(msg, sizeof(msg),
" -- Enable other hotkeys.\n"
" \n"
" If this hotkey is bound to either keyboard, \n"
"joybutton or joyaxis, all other hotkeys will \n"
"be disabled unless this hotkey is also held \n"
"at the same time. \n"
" \n"
"This is useful for RETRO_KEYBOARD centric \n"
"implementations which query a large area of \n"
"the keyboard, where it is not desirable that \n"
"hotkeys get in the way.");
break;
case MENU_SETTINGS_BIND_BEGIN + RARCH_VOLUME_UP:
snprintf(msg, sizeof(msg),
" -- Increases audio volume.");
break;
case MENU_SETTINGS_BIND_BEGIN + RARCH_VOLUME_DOWN:
snprintf(msg, sizeof(msg),
" -- Decreases audio volume.");
break;
case MENU_SETTINGS_BIND_BEGIN + RARCH_OVERLAY_NEXT:
snprintf(msg, sizeof(msg),
" -- Toggles to next overlay.\n"
" \n"
"Wraps around.");
break;
case MENU_SETTINGS_BIND_BEGIN + RARCH_DISK_EJECT_TOGGLE:
snprintf(msg, sizeof(msg),
" -- Toggles eject for disks.\n"
" \n"
"Used for multiple-disk content.");
break;
case MENU_SETTINGS_BIND_BEGIN + RARCH_DISK_NEXT:
snprintf(msg, sizeof(msg),
" -- Cycles through disk images. Use after \n"
"ejecting. \n"
" \n"
" Complete by toggling eject again.");
break;
case MENU_SETTINGS_BIND_BEGIN + RARCH_GRAB_MOUSE_TOGGLE:
snprintf(msg, sizeof(msg),
" -- Toggles mouse grab.\n"
" \n"
"When mouse is grabbed, RetroArch hides the \n"
"mouse, and keeps the mouse pointer inside \n"
"the window to allow relative mouse input to \n"
"work better.");
break;
case MENU_SETTINGS_BIND_BEGIN + RARCH_MENU_TOGGLE:
snprintf(msg, sizeof(msg),
" -- Toggles menu.");
break;
case MENU_SETTINGS_DRIVER_VIDEO:
if (!strcmp(g_settings.video.driver, "gl"))
snprintf(msg, sizeof(msg),
" -- OpenGL Video driver. \n"
" \n"
"This driver allows libretro GL cores to \n"
"be used in addition to software-rendered \n"
"core implementations.\n"
" \n"
"Performance for software-rendered and \n"
"libretro GL core implementations should be \n"
"optimal (depending on your graphics card's \n"
"underlying GL driver).");
else if (!strcmp(g_settings.video.driver, "sdl"))
snprintf(msg, sizeof(msg),
" -- SDL Video driver.\n"
" \n"
"This is an SDL 1.2 software-rendered video \n"
"driver.\n"
" \n"
"Performance is considered to be suboptimal. \n"
"Consider using it only as a last resort.\n"
" \n"
"WARNING: Menu support is currently not \n"
"supported with this driver.");
else if (!strcmp(g_settings.video.driver, "d3d"))
snprintf(msg, sizeof(msg),
" -- Direct3D Video driver. \n"
" \n"
"Performance for software-rendered cores \n"
"should be optimal (depending on your \n"
"graphics card's underlying D3D driver).");
else if (!strcmp(g_settings.video.driver, "lima"))
snprintf(msg, sizeof(msg),
" -- Lima Video Driver. \n"
" \n"
"This is a low-level Limare video driver. \n"
" \n"
"Performance for software rendered cores \n"
"should be optimal.");
else
snprintf(msg, sizeof(msg),
" -- Current Video driver.");
break;
case MENU_SETTINGS_DRIVER_AUDIO_RESAMPLER:
if (!strcmp(g_settings.audio.resampler, "sinc"))
snprintf(msg, sizeof(msg),
" -- Windowed SINC implementation.");
else if (!strcmp(g_settings.audio.resampler, "CC"))
snprintf(msg, sizeof(msg),
" -- Convoluted Cosine implementation.");
break;
case MENU_SETTINGS_SHADER_0_FILTER + (0 * 3):
case MENU_SETTINGS_SHADER_0_FILTER + (1 * 3):
case MENU_SETTINGS_SHADER_0_FILTER + (2 * 3):
case MENU_SETTINGS_SHADER_0_FILTER + (3 * 3):
case MENU_SETTINGS_SHADER_0_FILTER + (4 * 3):
case MENU_SETTINGS_SHADER_0_FILTER + (5 * 3):
case MENU_SETTINGS_SHADER_0_FILTER + (6 * 3):
case MENU_SETTINGS_SHADER_0_FILTER + (7 * 3):
case MENU_SETTINGS_SHADER_0_FILTER + (8 * 3):
case MENU_SETTINGS_SHADER_0_FILTER + (9 * 3):
case MENU_SETTINGS_SHADER_0_FILTER + (10 * 3):
case MENU_SETTINGS_SHADER_0_FILTER + (11 * 3):
case MENU_SETTINGS_SHADER_0_FILTER + (12 * 3):
case MENU_SETTINGS_SHADER_0_FILTER + (13 * 3):
case MENU_SETTINGS_SHADER_0_FILTER + (14 * 3):
case MENU_SETTINGS_SHADER_0_FILTER + (15 * 3):
snprintf(msg, sizeof(msg),
" -- Hardware filter for this pass. \n"
" \n"
"If 'Don't Care' is set, 'Default \n"
"Filter' will be used."
);
break;
case MENU_SETTINGS_SHADER_0 + (0 * 3):
case MENU_SETTINGS_SHADER_0 + (1 * 3):
case MENU_SETTINGS_SHADER_0 + (2 * 3):
case MENU_SETTINGS_SHADER_0 + (3 * 3):
case MENU_SETTINGS_SHADER_0 + (4 * 3):
case MENU_SETTINGS_SHADER_0 + (5 * 3):
case MENU_SETTINGS_SHADER_0 + (6 * 3):
case MENU_SETTINGS_SHADER_0 + (7 * 3):
case MENU_SETTINGS_SHADER_0 + (8 * 3):
case MENU_SETTINGS_SHADER_0 + (9 * 3):
case MENU_SETTINGS_SHADER_0 + (10 * 3):
case MENU_SETTINGS_SHADER_0 + (11 * 3):
case MENU_SETTINGS_SHADER_0 + (12 * 3):
case MENU_SETTINGS_SHADER_0 + (13 * 3):
case MENU_SETTINGS_SHADER_0 + (14 * 3):
case MENU_SETTINGS_SHADER_0 + (15 * 3):
snprintf(msg, sizeof(msg),
" -- Path to shader. \n"
" \n"
"All shaders must be of the same \n"
"type (i.e. CG, GLSL or HLSL). \n"
" \n"
"Set Shader Directory to set where \n"
"the browser starts to look for \n"
"shaders."
);
break;
case MENU_SETTINGS_SHADER_0_SCALE + (0 * 3):
case MENU_SETTINGS_SHADER_0_SCALE + (1 * 3):
case MENU_SETTINGS_SHADER_0_SCALE + (2 * 3):
case MENU_SETTINGS_SHADER_0_SCALE + (3 * 3):
case MENU_SETTINGS_SHADER_0_SCALE + (4 * 3):
case MENU_SETTINGS_SHADER_0_SCALE + (5 * 3):
case MENU_SETTINGS_SHADER_0_SCALE + (6 * 3):
case MENU_SETTINGS_SHADER_0_SCALE + (7 * 3):
case MENU_SETTINGS_SHADER_0_SCALE + (8 * 3):
case MENU_SETTINGS_SHADER_0_SCALE + (9 * 3):
case MENU_SETTINGS_SHADER_0_SCALE + (10 * 3):
case MENU_SETTINGS_SHADER_0_SCALE + (11 * 3):
case MENU_SETTINGS_SHADER_0_SCALE + (12 * 3):
case MENU_SETTINGS_SHADER_0_SCALE + (13 * 3):
case MENU_SETTINGS_SHADER_0_SCALE + (14 * 3):
case MENU_SETTINGS_SHADER_0_SCALE + (15 * 3):
snprintf(msg, sizeof(msg),
" -- Scale for this pass. \n"
" \n"
"The scale factor accumulates, i.e. 2x \n"
"for first pass and 2x for second pass \n"
"will give you a 4x total scale. \n"
" \n"
"If there is a scale factor for last \n"
"pass, the result is stretched to \n"
"screen with the filter specified in \n"
"'Default Filter'. \n"
" \n"
"If 'Don't Care' is set, either 1x \n"
"scale or stretch to fullscreen will \n"
"be used depending if it's not the last \n"
"pass or not."
);
break;
default:
snprintf(msg, sizeof(msg),
"-- No info on this item available. --\n");
}
if (driver.video_data && driver.menu_ctx && driver.menu_ctx->render_messagebox)
driver.menu_ctx->render_messagebox(msg);
if (action == MENU_ACTION_OK)
file_list_pop(driver.menu->menu_stack, &driver.menu->selection_ptr);
return 0;
}
static int menu_start_screen_iterate(unsigned action)
{
unsigned i;
char msg[1024];
if (!driver.menu)
return 0;
if (driver.video_data && driver.menu_ctx && driver.menu_ctx->render)
driver.menu_ctx->render();
static const unsigned binds[] = {
RETRO_DEVICE_ID_JOYPAD_UP,
RETRO_DEVICE_ID_JOYPAD_DOWN,
RETRO_DEVICE_ID_JOYPAD_A,
RETRO_DEVICE_ID_JOYPAD_B,
RETRO_DEVICE_ID_JOYPAD_SELECT,
RARCH_MENU_TOGGLE,
RARCH_QUIT_KEY,
};
char desc[ARRAY_SIZE(binds)][64];
for (i = 0; i < ARRAY_SIZE(binds); i++)
{
if (driver.input && driver.input->set_keybinds)
{
struct platform_bind key_label;
strlcpy(key_label.desc, "Unknown", sizeof(key_label.desc));
key_label.joykey = g_settings.input.binds[0][binds[i]].joykey;
driver.input->set_keybinds(&key_label, 0, 0, 0, 1ULL << KEYBINDS_ACTION_GET_BIND_LABEL);
strlcpy(desc[i], key_label.desc, sizeof(desc[i]));
}
else
{
const struct retro_keybind *bind = &g_settings.input.binds[0][binds[i]];
const struct retro_keybind *auto_bind = input_get_auto_bind(0, binds[i]);
input_get_bind_string(desc[i], bind, auto_bind, sizeof(desc[i]));
}
}
snprintf(msg, sizeof(msg),
"-- Welcome to RetroArch --\n"
" \n" // strtok_r doesn't split empty strings.
"Basic Menu controls:\n"
" Scroll (Up): %-20s\n"
" Scroll (Down): %-20s\n"
" Accept/OK: %-20s\n"
" Back: %-20s\n"
" Info: %-20s\n"
"Enter/Exit Menu: %-20s\n"
" Exit RetroArch: %-20s\n"
" \n"
"To run content:\n"
"Load a libretro core (Core).\n"
"Load a content file (Load Content). \n"
" \n"
"See Path Options to set directories\n"
"for faster access to files.\n"
" \n"
"Press Accept/OK to continue.",
desc[0], desc[1], desc[2], desc[3], desc[4], desc[5], desc[6]);
if (driver.video_data && driver.menu_ctx && driver.menu_ctx->render_messagebox)
driver.menu_ctx->render_messagebox(msg);
if (action == MENU_ACTION_OK)
file_list_pop(driver.menu->menu_stack, &driver.menu->selection_ptr);
return 0;
}
static unsigned menu_common_type_is(unsigned type)
{
unsigned ret = 0;
bool type_found;
type_found =
type == MENU_SETTINGS ||
type == MENU_SETTINGS_GENERAL_OPTIONS ||
type == MENU_SETTINGS_CORE_OPTIONS ||
type == MENU_SETTINGS_CORE_INFO ||
type == MENU_SETTINGS_VIDEO_OPTIONS ||
type == MENU_SETTINGS_FONT_OPTIONS ||
type == MENU_SETTINGS_SHADER_OPTIONS ||
type == MENU_SETTINGS_SHADER_PARAMETERS ||
type == MENU_SETTINGS_SHADER_PRESET_PARAMETERS ||
type == MENU_SETTINGS_AUDIO_OPTIONS ||
type == MENU_SETTINGS_DISK_OPTIONS ||
type == MENU_SETTINGS_PATH_OPTIONS ||
type == MENU_SETTINGS_PRIVACY_OPTIONS ||
type == MENU_SETTINGS_OVERLAY_OPTIONS ||
type == MENU_SETTINGS_NETPLAY_OPTIONS ||
type == MENU_SETTINGS_OPTIONS ||
type == MENU_SETTINGS_DRIVERS ||
type == MENU_SETTINGS_PERFORMANCE_COUNTERS ||
type == MENU_SETTINGS_PERFORMANCE_COUNTERS_LIBRETRO ||
type == MENU_SETTINGS_PERFORMANCE_COUNTERS_FRONTEND ||
(type == MENU_SETTINGS_INPUT_OPTIONS);
if (type_found)
{
ret = MENU_SETTINGS;
return ret;
}
type_found = (type >= MENU_SETTINGS_SHADER_0 &&
type <= MENU_SETTINGS_SHADER_LAST &&
((type - MENU_SETTINGS_SHADER_0) % 3) == 0) ||
type == MENU_SETTINGS_SHADER_PRESET;
if (type_found)
{
ret = MENU_SETTINGS_SHADER_OPTIONS;
return ret;
}
type_found =
type == MENU_BROWSER_DIR_PATH ||
type == MENU_CONTENT_DIR_PATH ||
type == MENU_ASSETS_DIR_PATH ||
type == MENU_SHADER_DIR_PATH ||
type == MENU_FILTER_DIR_PATH ||
type == MENU_DSP_FILTER_DIR_PATH ||
type == MENU_SAVESTATE_DIR_PATH ||
type == MENU_LIBRETRO_DIR_PATH ||
type == MENU_LIBRETRO_INFO_DIR_PATH ||
type == MENU_CONFIG_DIR_PATH ||
type == MENU_SAVEFILE_DIR_PATH ||
type == MENU_OVERLAY_DIR_PATH ||
type == MENU_SCREENSHOT_DIR_PATH ||
type == MENU_AUTOCONFIG_DIR_PATH ||
type == MENU_SYSTEM_DIR_PATH;
if (type_found)
{
ret = MENU_FILE_DIRECTORY;
return ret;
}
return ret;
}
static int menu_settings_iterate(unsigned action)
{
if (!driver.menu)
return 0;
driver.menu->frame_buf_pitch = driver.menu->width * 2;
unsigned type = 0;
const char *label = NULL;
if (action != MENU_ACTION_REFRESH)
file_list_get_at_offset(driver.menu->selection_buf, driver.menu->selection_ptr, &label, &type);
if (type == MENU_SETTINGS_CORE)
label = g_settings.libretro_directory;
else if (type == MENU_SETTINGS_CONFIG)
label = g_settings.menu_config_directory;
else if (type == MENU_SETTINGS_DISK_APPEND)
label = g_settings.menu_content_directory;
const char *dir = NULL;
unsigned menu_type = 0;
file_list_get_last(driver.menu->menu_stack, &dir, &menu_type);
if (driver.menu->need_refresh)
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:
if (file_list_get_size(driver.menu->menu_stack) > 1)
{
file_list_pop(driver.menu->menu_stack, &driver.menu->selection_ptr);
driver.menu->need_refresh = true;
}
break;
case MENU_ACTION_SELECT:
{
const char *path = NULL;
file_list_get_at_offset(driver.menu->selection_buf, driver.menu->selection_ptr, &path, &driver.menu->info_selection);
file_list_push(driver.menu->menu_stack, "", MENU_INFO_SCREEN, driver.menu->selection_ptr);
}
break;
case MENU_ACTION_LEFT:
case MENU_ACTION_RIGHT:
case MENU_ACTION_OK:
case MENU_ACTION_START:
if ((type == MENU_SETTINGS_OPEN_FILEBROWSER || type == MENU_SETTINGS_OPEN_FILEBROWSER_DEFERRED_CORE)
&& action == MENU_ACTION_OK)
{
driver.menu->defer_core = type == MENU_SETTINGS_OPEN_FILEBROWSER_DEFERRED_CORE;
file_list_push(driver.menu->menu_stack, g_settings.menu_content_directory, MENU_FILE_DIRECTORY, driver.menu->selection_ptr);
menu_clear_navigation(driver.menu);
driver.menu->need_refresh = true;
}
else if ((type == MENU_SETTINGS_OPEN_HISTORY || menu_common_type_is(type) == MENU_FILE_DIRECTORY) && action == MENU_ACTION_OK)
{
file_list_push(driver.menu->menu_stack, "", type, driver.menu->selection_ptr);
menu_clear_navigation(driver.menu);
driver.menu->need_refresh = true;
}
else if ((menu_common_type_is(type) == MENU_SETTINGS || type == MENU_SETTINGS_CORE || type == MENU_SETTINGS_CONFIG || type == MENU_SETTINGS_DISK_APPEND) && action == MENU_ACTION_OK)
{
file_list_push(driver.menu->menu_stack, label, type, driver.menu->selection_ptr);
menu_clear_navigation(driver.menu);
driver.menu->need_refresh = true;
}
else if (type == MENU_SETTINGS_CUSTOM_VIEWPORT && action == MENU_ACTION_OK)
{
file_list_push(driver.menu->menu_stack, "", type, driver.menu->selection_ptr);
// Start with something sane.
rarch_viewport_t *custom = &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;
if (driver.video_data && driver.video_poke && driver.video_poke->set_aspect_ratio)
driver.video_poke->set_aspect_ratio(driver.video_data,
g_settings.video.aspect_ratio_idx);
}
else
{
int ret = 0;
if (driver.menu_ctx && driver.menu_ctx->backend && driver.menu_ctx->backend->setting_toggle)
ret = driver.menu_ctx->backend->setting_toggle(type, action, menu_type);
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, &dir, &menu_type);
if (driver.menu->need_refresh && !(menu_type == MENU_FILE_DIRECTORY ||
menu_common_type_is(menu_type) == MENU_SETTINGS_SHADER_OPTIONS ||
menu_common_type_is(menu_type) == MENU_FILE_DIRECTORY ||
menu_type == MENU_SETTINGS_VIDEO_SOFTFILTER ||
menu_type == MENU_SETTINGS_AUDIO_DSP_FILTER ||
menu_type == MENU_SETTINGS_OVERLAY_PRESET ||
menu_type == MENU_SETTINGS_CORE ||
menu_type == MENU_SETTINGS_CONFIG ||
menu_type == MENU_SETTINGS_DISK_APPEND ||
menu_type == MENU_SETTINGS_OPEN_HISTORY))
{
driver.menu->need_refresh = false;
if (
menu_type == MENU_SETTINGS_INPUT_OPTIONS
|| menu_type == MENU_SETTINGS_PATH_OPTIONS
|| menu_type == MENU_SETTINGS_OVERLAY_OPTIONS
|| menu_type == MENU_SETTINGS_NETPLAY_OPTIONS
|| menu_type == MENU_SETTINGS_OPTIONS
|| menu_type == MENU_SETTINGS_DRIVERS
|| menu_type == MENU_SETTINGS_PERFORMANCE_COUNTERS
|| menu_type == MENU_SETTINGS_PERFORMANCE_COUNTERS_FRONTEND
|| menu_type == MENU_SETTINGS_PERFORMANCE_COUNTERS_LIBRETRO
|| menu_type == MENU_SETTINGS_CORE_INFO
|| menu_type == MENU_SETTINGS_CORE_OPTIONS
|| menu_type == MENU_SETTINGS_AUDIO_OPTIONS
|| menu_type == MENU_SETTINGS_DISK_OPTIONS
|| menu_type == MENU_SETTINGS_PRIVACY_OPTIONS
|| menu_type == MENU_SETTINGS_GENERAL_OPTIONS
|| menu_type == MENU_SETTINGS_VIDEO_OPTIONS
|| menu_type == MENU_SETTINGS_FONT_OPTIONS
|| menu_type == MENU_SETTINGS_SHADER_OPTIONS
|| menu_type == MENU_SETTINGS_SHADER_PARAMETERS
|| menu_type == MENU_SETTINGS_SHADER_PRESET_PARAMETERS
)
menu_common_entries_init(driver.menu, menu_type);
else
menu_common_entries_init(driver.menu, MENU_SETTINGS);
}
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, "", MENU_START_SCREEN, 0);
}
return 0;
}
static int menu_viewport_iterate(unsigned action)
{
rarch_viewport_t *custom = &g_extern.console.screen.viewports.custom_vp;
if (!driver.menu)
return 0;
unsigned menu_type = 0;
file_list_get_last(driver.menu->menu_stack, NULL, &menu_type);
struct retro_game_geometry *geom = &g_extern.system.av_info.geometry;
int stride_x = g_settings.video.scale_integer ?
geom->base_width : 1;
int stride_y = g_settings.video.scale_integer ?
geom->base_height : 1;
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;
if (driver.video_data && driver.video_poke && driver.video_poke->apply_state_changes)
driver.video_poke->apply_state_changes(driver.video_data);
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;
if (driver.video_data && driver.video_poke && driver.video_poke->apply_state_changes)
driver.video_poke->apply_state_changes(driver.video_data);
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;
if (driver.video_data && driver.video_poke && driver.video_poke->apply_state_changes)
driver.video_poke->apply_state_changes(driver.video_data);
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;
if (driver.video_data && driver.video_poke && driver.video_poke->apply_state_changes)
driver.video_poke->apply_state_changes(driver.video_data);
break;
case MENU_ACTION_CANCEL:
file_list_pop(driver.menu->menu_stack, &driver.menu->selection_ptr);
if (menu_type == MENU_SETTINGS_CUSTOM_VIEWPORT_2)
{
file_list_push(driver.menu->menu_stack, "",
MENU_SETTINGS_CUSTOM_VIEWPORT,
driver.menu->selection_ptr);
}
break;
case MENU_ACTION_OK:
file_list_pop(driver.menu->menu_stack, &driver.menu->selection_ptr);
if (menu_type == MENU_SETTINGS_CUSTOM_VIEWPORT
&& !g_settings.video.scale_integer)
{
file_list_push(driver.menu->menu_stack, "",
MENU_SETTINGS_CUSTOM_VIEWPORT_2,
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;
}
if (driver.video_data && driver.video_poke && driver.video_poke->apply_state_changes)
driver.video_poke->apply_state_changes(driver.video_data);
}
break;
case MENU_ACTION_MESSAGE:
driver.menu->msg_force = true;
break;
default:
break;
}
file_list_get_last(driver.menu->menu_stack, NULL, &menu_type);
if (driver.video_data && driver.menu_ctx && driver.menu_ctx->render)
driver.menu_ctx->render();
const char *base_msg = NULL;
char msg[64];
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 (menu_type == MENU_SETTINGS_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;
if (driver.video_data && driver.video_poke && driver.video_poke->apply_state_changes)
driver.video_poke->apply_state_changes(driver.video_data);
return 0;
}
static void menu_parse_and_resolve(unsigned menu_type)
{
const core_info_t *info = NULL;
const char *dir;
size_t i, list_size;
file_list_t *list;
if (!driver.menu)
{
RARCH_ERR("Cannot parse and resolve menu, menu handle is not initialized.\n");
return;
}
dir = NULL;
file_list_clear(driver.menu->selection_buf);
// parsing switch
switch (menu_type)
{
case MENU_SETTINGS_OPEN_HISTORY:
/* History parse */
list_size = rom_history_size(driver.menu->history);
for (i = 0; i < list_size; i++)
{
const char *path, *core_path, *core_name;
char fill_buf[PATH_MAX];
path = NULL;
core_path = NULL;
core_name = NULL;
rom_history_get_index(driver.menu->history, i,
&path, &core_path, &core_name);
if (path)
{
char path_short[PATH_MAX];
fill_pathname(path_short, path_basename(path), "", sizeof(path_short));
snprintf(fill_buf, sizeof(fill_buf), "%s (%s)",
path_short, core_name);
}
else
strlcpy(fill_buf, core_name, sizeof(fill_buf));
file_list_push(driver.menu->selection_buf, fill_buf, MENU_FILE_PLAIN, 0);
}
break;
case MENU_SETTINGS_DEFERRED_CORE:
break;
default:
{
/* Directory parse */
file_list_get_last(driver.menu->menu_stack, &dir, &menu_type);
if (!*dir)
{
#if defined(GEKKO)
#ifdef HW_RVL
file_list_push(driver.menu->selection_buf, "sd:/", menu_type, 0);
file_list_push(driver.menu->selection_buf, "usb:/", menu_type, 0);
#endif
file_list_push(driver.menu->selection_buf, "carda:/", menu_type, 0);
file_list_push(driver.menu->selection_buf, "cardb:/", menu_type, 0);
#elif defined(_XBOX1)
file_list_push(driver.menu->selection_buf, "C:", menu_type, 0);
file_list_push(driver.menu->selection_buf, "D:", menu_type, 0);
file_list_push(driver.menu->selection_buf, "E:", menu_type, 0);
file_list_push(driver.menu->selection_buf, "F:", menu_type, 0);
file_list_push(driver.menu->selection_buf, "G:", menu_type, 0);
#elif defined(_XBOX360)
file_list_push(driver.menu->selection_buf, "game:", menu_type, 0);
#elif defined(_WIN32)
unsigned drives = GetLogicalDrives();
char drive[] = " :\\";
for (i = 0; i < 32; i++)
{
drive[0] = 'A' + i;
if (drives & (1 << i))
file_list_push(driver.menu->selection_buf, drive, menu_type, 0);
}
#elif defined(__CELLOS_LV2__)
file_list_push(driver.menu->selection_buf, "/app_home/", menu_type, 0);
file_list_push(driver.menu->selection_buf, "/dev_hdd0/", menu_type, 0);
file_list_push(driver.menu->selection_buf, "/dev_hdd1/", menu_type, 0);
file_list_push(driver.menu->selection_buf, "/host_root/", menu_type, 0);
file_list_push(driver.menu->selection_buf, "/dev_usb000/", menu_type, 0);
file_list_push(driver.menu->selection_buf, "/dev_usb001/", menu_type, 0);
file_list_push(driver.menu->selection_buf, "/dev_usb002/", menu_type, 0);
file_list_push(driver.menu->selection_buf, "/dev_usb003/", menu_type, 0);
file_list_push(driver.menu->selection_buf, "/dev_usb004/", menu_type, 0);
file_list_push(driver.menu->selection_buf, "/dev_usb005/", menu_type, 0);
file_list_push(driver.menu->selection_buf, "/dev_usb006/", menu_type, 0);
#elif defined(PSP)
file_list_push(driver.menu->selection_buf, "ms0:/", menu_type, 0);
file_list_push(driver.menu->selection_buf, "ef0:/", menu_type, 0);
file_list_push(driver.menu->selection_buf, "host0:/", menu_type, 0);
#else
file_list_push(driver.menu->selection_buf, "/", menu_type, 0);
#endif
return;
}
#if defined(GEKKO) && defined(HW_RVL)
LWP_MutexLock(gx_device_mutex);
int dev = gx_get_device_from_path(dir);
if (dev != -1 && !gx_devices[dev].mounted && gx_devices[dev].interface->isInserted())
fatMountSimple(gx_devices[dev].name, gx_devices[dev].interface);
LWP_MutexUnlock(gx_device_mutex);
#endif
const char *exts;
char ext_buf[1024];
if (menu_type == MENU_SETTINGS_CORE)
exts = EXT_EXECUTABLES;
else if (menu_type == MENU_SETTINGS_CONFIG)
exts = "cfg";
else if (menu_type == MENU_SETTINGS_SHADER_PRESET)
exts = "cgp|glslp";
else if (menu_common_type_is(menu_type) == MENU_SETTINGS_SHADER_OPTIONS)
exts = "cg|glsl";
else if (menu_type == MENU_SETTINGS_VIDEO_SOFTFILTER)
exts = EXT_EXECUTABLES;
else if (menu_type == MENU_SETTINGS_AUDIO_DSP_FILTER)
exts = "dsp";
else if (menu_type == MENU_SETTINGS_OVERLAY_PRESET)
exts = "cfg";
else if (menu_common_type_is(menu_type) == MENU_FILE_DIRECTORY)
exts = ""; // we ignore files anyway
else if (driver.menu->defer_core)
exts = driver.menu->core_info ? core_info_list_get_all_extensions(driver.menu->core_info) : "";
else if (driver.menu->info.valid_extensions)
{
exts = ext_buf;
if (*driver.menu->info.valid_extensions)
snprintf(ext_buf, sizeof(ext_buf), "%s|zip", driver.menu->info.valid_extensions);
else
*ext_buf = '\0';
}
else
exts = g_extern.system.valid_extensions;
struct string_list *list = dir_list_new(dir, exts, true);
if (!list)
return;
dir_list_sort(list, true);
if (menu_common_type_is(menu_type) == MENU_FILE_DIRECTORY)
file_list_push(driver.menu->selection_buf, "