RetroArch/menu/menu_setting.c
Eric Warmenhoven 5fd4eb905c
iOS QOL improvements (#16444)
* iOS/tvOS: bundle cores as frameworks as opposed to dylibs

* iOS/tvOS: update plist to indicate controller support

* iOS/tvOS: living within the sandbox

* iOS/tvOS: import content through share sheet

* iOS/tvOS: default audio sync off due to crash on background

* iOS/tvOS: don't try altkit if there's no reason to

* iOS/tvOS: enumerate cores for appstore distribution
2024-04-18 03:01:39 -07:00

24265 lines
917 KiB
C

/* RetroArch - A frontend for libretro.
* Copyright (C) 2010-2014 - Hans-Kristian Arntzen
* Copyright (C) 2011-2017 - Daniel De Matteis
* Copyright (C) 2014-2017 - Jean-André Santoni
* Copyright (C) 2016-2019 - Brad Parker
*
* 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 <http://www.gnu.org/licenses/>.
*/
#ifdef _WIN32
#include <direct.h>
#else
#include <unistd.h>
#endif
#include <libretro.h>
#include <lists/file_list.h>
#include <file/file_path.h>
#include <string/stdstring.h>
#include <lists/string_list.h>
#include <streams/file_stream.h>
#include <audio/audio_resampler.h>
#include <compat/strl.h>
#ifdef HAVE_CONFIG_H
#include "../config.h"
#endif
#include "menu_setting.h"
#include "menu_cbs.h"
#include "menu_driver.h"
#include "menu_input.h"
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
#include "menu_shader.h"
#endif
#if defined(HAVE_STEAM) && defined(HAVE_MIST)
#include <mist.h>
#endif
#ifdef HAVE_CDROM
#include <vfs/vfs_implementation_cdrom.h>
#endif
#ifdef HAVE_WASAPI
#include "../audio/common/wasapi.h"
#endif
#include "../config.def.h"
#include "../config.def.keybinds.h"
#if !defined(__PSL1GHT__) && defined(__PS3__)
#include <sysutil/sysutil_bgmplayback.h>
#endif
#ifdef HAVE_CHEEVOS
#include "../cheevos/cheevos.h"
#include "../cheevos/cheevos_locals.h"
#endif
#ifdef HAVE_TRANSLATE
#include "../translation_defines.h"
#endif
#include "../frontend/frontend_driver.h"
#include "../camera/camera_driver.h"
#include "../gfx/gfx_animation.h"
#ifdef HAVE_GFX_WIDGETS
#include "../gfx/gfx_widgets.h"
#endif
#include "../core.h"
#include "../configuration.h"
#include "../msg_hash.h"
#include "../defaults.h"
#include "../driver.h"
#include "../paths.h"
#include "../dynamic.h"
#include "../list_special.h"
#include "../audio/audio_driver.h"
#ifdef HAVE_MICROPHONE
#include "../audio/microphone_driver.h"
#endif
#ifdef HAVE_BLUETOOTH
#include "../bluetooth/bluetooth_driver.h"
#endif
#include "../midi_driver.h"
#include "../location_driver.h"
#include "../network/cloud_sync_driver.h"
#include "../record/record_driver.h"
#include "../tasks/tasks_internal.h"
#include "../config.def.h"
#include "../ui/ui_companion_driver.h"
#include "../performance_counters.h"
#include "../setting_list.h"
#include "../lakka.h"
#ifdef HAVE_LAKKA_SWITCH
#include "../lakka-switch.h"
#endif
#include "../retroarch.h"
#include "../gfx/video_display_server.h"
#ifdef HAVE_CHEATS
#include "../cheat_manager.h"
#endif
#include "../verbosity.h"
#include "../playlist.h"
#include "../manual_content_scan.h"
#include "../input/input_remapping.h"
#include "../tasks/tasks_internal.h"
#ifdef HAVE_NETWORKING
#include "../network/netplay/netplay.h"
#ifdef HAVE_WIFI
#include "../network/wifi_driver.h"
#endif
#endif
#if defined(HAVE_OVERLAY)
#include "../input/input_overlay.h"
#endif
/* Required for 3DS display mode setting */
#if defined(_3DS)
#include <3ds/services/cfgu.h>
#include "gfx/common/ctr_defines.h"
#endif
#if defined(DINGUX)
#include "../dingux/dingux_utils.h"
#endif
#if defined(ANDROID)
#include "../play_feature_delivery/play_feature_delivery.h"
#endif
#ifdef HAVE_LANGEXTRA
#include "../intl/progress.h"
#endif
#define _3_SECONDS 3000000
#define _6_SECONDS 6000000
#define _9_SECONDS 9000000
#define _12_SECONDS 12000000
#define _15_SECONDS 15000000
#define _18_SECONDS 18000000
#define _21_SECONDS 21000000
#define CONFIG_SIZE(a, b, c, d, e, f, g, h, i, j, k, l) \
if (SETTINGS_LIST_APPEND(a, b)) \
config_size(a, b, c, d, e, f, g, h, i, j, k, l)
#define CONFIG_BOOL_ALT(a, b, c, d, e, f, g, h, i, j, k, l, m, n) \
if (SETTINGS_LIST_APPEND(a, b)) \
config_bool_alt(a, b, c, d, e, f, g, h, i, j, k, l, m, n)
#define CONFIG_BOOL(a, b, c, d, e, f, g, h, i, j, k, l, m, n) \
if (SETTINGS_LIST_APPEND(a, b)) \
config_bool(a, b, c, d, e, f, g, h, i, j, k, l, m, n)
#define CONFIG_INT(a, b, c, d, e, f, g, h, i, j, k) \
if (SETTINGS_LIST_APPEND(a, b)) \
config_int(a, b, c, d, e, f, g, h, i, j, k)
#define CONFIG_UINT_ALT(a, b, c, d, e, f, g, h, i, j, k) \
if (SETTINGS_LIST_APPEND(a, b)) \
config_uint_alt(a, b, c, d, e, f, g, h, i, j, k)
#define CONFIG_UINT(a, b, c, d, e, f, g, h, i, j, k) \
if (SETTINGS_LIST_APPEND(a, b)) \
config_uint(a, b, c, d, e, f, g, h, i, j, k)
#define CONFIG_STRING(a, b, c, d, e, f, g, h, i, j, k, l) \
if (SETTINGS_LIST_APPEND(a, b)) \
config_string(a, b, c, d, e, f, g, h, i, j, k, l)
#define CONFIG_FLOAT(a, b, c, d, e, f, g, h, i, j, k, l) \
if (SETTINGS_LIST_APPEND(a, b)) \
config_float(a, b, c, d, e, f, g, h, i, j, k, l)
#define CONFIG_DIR(a, b, c, d, e, f, g, h, i, j, k, l, m) \
if (SETTINGS_LIST_APPEND(a, b)) \
config_dir(a, b, c, d, e, f, g, h, i, j, k, l, m)
#define CONFIG_PATH(a, b, c, d, e, f, g, h, i, j, k, l) \
if (SETTINGS_LIST_APPEND(a, b)) \
config_path(a, b, c, d, e, f, g, h, i, j, k, l)
#define CONFIG_ACTION_ALT(a, b, c, d, e, f, g) \
if (SETTINGS_LIST_APPEND(a, b)) \
config_action_alt(a, b, c, d, e, f, g)
#define CONFIG_ACTION(a, b, c, d, e, f, g) \
if (SETTINGS_LIST_APPEND(a, b)) \
config_action(a, b, c, d, e, f, g)
#define END_GROUP(a, b, c) \
if (SETTINGS_LIST_APPEND(a, b)) \
end_group(a, b, c)
#define START_SUB_GROUP(a, b, c, d, e, f) \
if (SETTINGS_LIST_APPEND(a, b)) \
start_sub_group(a, b, c, d, e, f)
#define END_SUB_GROUP(a, b, c) \
if (SETTINGS_LIST_APPEND(a, b)) \
end_sub_group(a, b, c)
#define CONFIG_STRING_OPTIONS(a, b, c, d, e, f, g, h, i, j, k, l, m) \
if (SETTINGS_LIST_APPEND(a, b)) \
config_string_options(a, b, c, d, e, f, g, h, i, j, k, l, m)
#define CONFIG_HEX(a, b, c, d, e, f, g, h, i, j, k, l) \
if (SETTINGS_LIST_APPEND(a, b)) \
config_hex(a, b, c, d, e, f, g, h, i, j, k, l)
#define CONFIG_BIND_ALT(a, b, c, d, e, f, g, h, i, j, k) \
if (SETTINGS_LIST_APPEND(a, b)) \
config_bind_alt(a, b, c, d, e, f, g, h, i, j, k)
#define CONFIG_BIND(a, b, c, d, e, f, g, h, i, j, k, l) \
if (SETTINGS_LIST_APPEND(a, b)) \
config_bind(a, b, c, d, e, f, g, h, i, j, k, l)
#define SETTINGS_DATA_LIST_CURRENT_ADD_FREE_FLAGS(a, b, c) \
(*a)[b->index - 1].free_flags |= c
#define MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_IDX_PTR(a, b, c) \
(*a)[b->index - 1].enum_idx = c
#define MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_VALUE_IDX(a, b, c) \
(*a)[b->index - 1].enum_value_idx = c
#define SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(a, b, c) \
{ \
(*a)[b->index - 1].flags |= c; \
setting_add_special_callbacks(a, b, c); \
}
#define SETTINGS_LIST_APPEND(a, b) ((a && *a && b) ? ((((b)->index == (b)->size)) ? SETTINGS_LIST_APPEND_internal(a, b) : true) : false)
#define MENU_SETTINGS_LIST_CURRENT_IDX(list_info) (list_info->index - 1)
#define MENU_SETTINGS_LIST_CURRENT_ADD_VALUES(list, list_info, str) ((*(list))[MENU_SETTINGS_LIST_CURRENT_IDX((list_info))].values = (str))
#define MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, str) (*(list))[MENU_SETTINGS_LIST_CURRENT_IDX(list_info)].cmd_trigger_idx = (str)
#define CONFIG_UINT_CBS(var, label, left, right, msg_enum_base, string_rep, min, max, step) \
CONFIG_UINT( \
list, list_info, \
&(var), \
MENU_ENUM_LABEL_##label, \
MENU_ENUM_LABEL_VALUE_##label, \
var, \
&group_info, \
&subgroup_info, \
parent_group, \
general_write_handler, \
general_read_handler); \
(*list)[list_info->index - 1].action_left = left; \
(*list)[list_info->index - 1].action_right = right; \
(*list)[list_info->index - 1].get_string_representation = string_rep; \
(*list)[list_info->index - 1].index_offset = msg_enum_base; \
menu_settings_list_current_add_range(list, list_info, min, max, step, true, true);
enum settings_list_type
{
SETTINGS_LIST_NONE = 0,
SETTINGS_LIST_MAIN_MENU,
SETTINGS_LIST_DRIVERS,
SETTINGS_LIST_CORE,
SETTINGS_LIST_CONFIGURATION,
SETTINGS_LIST_LOGGING,
SETTINGS_LIST_SAVING,
SETTINGS_LIST_CLOUD_SYNC,
SETTINGS_LIST_REWIND,
SETTINGS_LIST_CHEAT_DETAILS,
SETTINGS_LIST_CHEAT_SEARCH,
SETTINGS_LIST_CHEATS,
SETTINGS_LIST_VIDEO,
SETTINGS_LIST_CRT_SWITCHRES,
SETTINGS_LIST_AUDIO,
#ifdef HAVE_MICROPHONE
SETTINGS_LIST_MICROPHONE,
#endif
SETTINGS_LIST_INPUT,
SETTINGS_LIST_INPUT_TURBO_FIRE,
SETTINGS_LIST_INPUT_HOTKEY,
SETTINGS_LIST_INPUT_RETROPAD_BINDS,
SETTINGS_LIST_RECORDING,
SETTINGS_LIST_FRAME_THROTTLING,
SETTINGS_LIST_FRAME_TIME_COUNTER,
SETTINGS_LIST_ONSCREEN_NOTIFICATIONS,
SETTINGS_LIST_OVERLAY,
SETTINGS_LIST_OSK_OVERLAY,
SETTINGS_LIST_OVERLAY_MOUSE,
SETTINGS_LIST_OVERLAY_LIGHTGUN,
SETTINGS_LIST_MENU,
SETTINGS_LIST_MENU_FILE_BROWSER,
SETTINGS_LIST_MULTIMEDIA,
SETTINGS_LIST_AI_SERVICE,
SETTINGS_LIST_ACCESSIBILITY,
SETTINGS_LIST_USER_INTERFACE,
SETTINGS_LIST_POWER_MANAGEMENT,
SETTINGS_LIST_WIFI_MANAGEMENT,
SETTINGS_LIST_MENU_SOUNDS,
SETTINGS_LIST_PLAYLIST,
SETTINGS_LIST_CHEEVOS,
SETTINGS_LIST_CHEEVOS_APPEARANCE,
SETTINGS_LIST_CHEEVOS_VISIBILITY,
SETTINGS_LIST_CORE_UPDATER,
SETTINGS_LIST_NETPLAY,
SETTINGS_LIST_LAKKA_SERVICES,
#ifdef HAVE_LAKKA_SWITCH
SETTINGS_LIST_LAKKA_SWITCH_OPTIONS,
#endif
SETTINGS_LIST_USER,
SETTINGS_LIST_USER_ACCOUNTS,
SETTINGS_LIST_USER_ACCOUNTS_CHEEVOS,
SETTINGS_LIST_USER_ACCOUNTS_YOUTUBE,
SETTINGS_LIST_USER_ACCOUNTS_TWITCH,
SETTINGS_LIST_USER_ACCOUNTS_FACEBOOK,
SETTINGS_LIST_DIRECTORY,
SETTINGS_LIST_PRIVACY,
SETTINGS_LIST_MIDI,
#ifdef HAVE_MIST
SETTINGS_LIST_STEAM,
#endif
SETTINGS_LIST_MANUAL_CONTENT_SCAN
};
struct bool_entry
{
bool *target;
uint32_t flags;
enum msg_hash_enums name_enum_idx;
enum msg_hash_enums SHORT_enum_idx;
enum msg_hash_enums off_enum_idx;
enum msg_hash_enums on_enum_idx;
bool default_value;
};
struct string_options_entry
{
const char *default_value;
const char *values;
char *target;
size_t len;
enum msg_hash_enums name_enum_idx;
enum msg_hash_enums SHORT_enum_idx;
};
typedef struct rarch_setting_info
{
int index;
int size;
} rarch_setting_info_t;
/* SETTINGS LIST */
/**
* setting_set_with_string_representation:
* @setting : pointer to setting
* @value : value for the setting (string)
*
* Set a settings' value with a string. It is assumed
* that the string has been properly formatted.
**/
static int setting_set_with_string_representation(rarch_setting_t* setting,
const char* value)
{
switch (setting->type)
{
case ST_INT:
{
char *ptr;
uint32_t flags = setting->flags;
*setting->value.target.integer = (int)strtol(value, &ptr, 10);
if (flags & SD_FLAG_HAS_RANGE)
{
float min = setting->min;
float max = setting->max;
if (flags & SD_FLAG_ENFORCE_MINRANGE && *setting->value.target.integer < min)
*setting->value.target.integer = min;
if (flags & SD_FLAG_ENFORCE_MAXRANGE && *setting->value.target.integer > max)
{
settings_t *settings = config_get_ptr();
if (settings && settings->bools.menu_navigation_wraparound_enable)
*setting->value.target.integer = min;
else
*setting->value.target.integer = max;
}
}
}
break;
case ST_UINT:
{
char *ptr;
uint32_t flags = setting->flags;
*setting->value.target.unsigned_integer = (unsigned int)strtoul(value, &ptr, 10);
if (flags & SD_FLAG_HAS_RANGE)
{
float min = setting->min;
float max = setting->max;
if (flags & SD_FLAG_ENFORCE_MINRANGE && *setting->value.target.unsigned_integer < min)
*setting->value.target.unsigned_integer = min;
if (flags & SD_FLAG_ENFORCE_MAXRANGE && *setting->value.target.unsigned_integer > max)
{
settings_t *settings = config_get_ptr();
if (settings && settings->bools.menu_navigation_wraparound_enable)
*setting->value.target.unsigned_integer = min;
else
*setting->value.target.unsigned_integer = max;
}
}
}
break;
case ST_SIZE:
{
uint32_t flags = setting->flags;
sscanf(value, "%" PRI_SIZET, setting->value.target.sizet);
if (flags & SD_FLAG_HAS_RANGE)
{
float min = setting->min;
float max = setting->max;
if (flags & SD_FLAG_ENFORCE_MINRANGE && *setting->value.target.sizet < min)
*setting->value.target.sizet = min;
if (flags & SD_FLAG_ENFORCE_MAXRANGE && *setting->value.target.sizet > max)
{
settings_t *settings = config_get_ptr();
if (settings && settings->bools.menu_navigation_wraparound_enable)
*setting->value.target.sizet = min;
else
*setting->value.target.sizet = max;
}
}
}
break;
case ST_FLOAT:
{
char *ptr;
uint32_t flags = setting->flags;
/* strtof() is C99/POSIX. Just use the more portable kind. */
*setting->value.target.fraction = (float)strtod(value, &ptr);
if (flags & SD_FLAG_HAS_RANGE)
{
float min = setting->min;
float max = setting->max;
if (flags & SD_FLAG_ENFORCE_MINRANGE && *setting->value.target.fraction < min)
*setting->value.target.fraction = min;
if (flags & SD_FLAG_ENFORCE_MAXRANGE && *setting->value.target.fraction > max)
{
settings_t *settings = config_get_ptr();
if (settings && settings->bools.menu_navigation_wraparound_enable)
*setting->value.target.fraction = min;
else
*setting->value.target.fraction = max;
}
}
}
break;
case ST_PATH:
case ST_DIR:
case ST_STRING:
case ST_STRING_OPTIONS:
case ST_ACTION:
if (setting->value.target.string)
strlcpy(setting->value.target.string, value, setting->size);
break;
case ST_BOOL:
if (string_is_equal(value, "true"))
*setting->value.target.boolean = true;
else if (string_is_equal(value, "false"))
*setting->value.target.boolean = false;
break;
default:
break;
}
if (setting->change_handler)
setting->change_handler(setting);
return 0;
}
static void menu_input_st_uint_cb(void *userdata, const char *str)
{
if (str && *str)
{
const char *ptr = NULL;
unsigned value = 0;
int chars_read = 0;
int ret = 0;
/* Ensure that input string contains a valid
* unsigned value
* Note: sscanf() will accept negative number
* strings here and overflow, so have to check
* for minus characters first... */
for (ptr = str; *ptr != '\0'; ptr++)
{
if (*ptr == '-')
{
menu_input_dialog_end();
return;
}
}
ret = sscanf(str, "%u %n", &value, &chars_read);
if ((ret == 1) && !str[chars_read])
{
struct menu_state *menu_st = menu_state_get_ptr();
const char *label = menu_st->input_dialog_kb_label_setting;
if (!string_is_empty(label))
{
rarch_setting_t *setting = NULL;
if ((setting = menu_setting_find(label)))
setting_set_with_string_representation(setting, str);
}
}
}
menu_input_dialog_end();
}
static void menu_input_st_int_cb(void *userdata, const char *str)
{
if (str && *str)
{
int value = 0;
int chars_read = 0;
/* Ensure that input string contains a valid
* unsigned value */
int ret = sscanf(str, "%d %n", &value, &chars_read);
if ((ret == 1) && !str[chars_read])
{
struct menu_state *menu_st = menu_state_get_ptr();
const char *label = menu_st->input_dialog_kb_label_setting;
if (!string_is_empty(label))
{
rarch_setting_t *setting = NULL;
if ((setting = menu_setting_find(label)))
setting_set_with_string_representation(setting, str);
}
}
}
menu_input_dialog_end();
}
static void menu_input_st_float_cb(void *userdata, const char *str)
{
if (str && *str)
{
float value = 0.0f;
int chars_read = 0;
/* Ensure that input string contains a valid
* floating point value */
int ret = sscanf(str, "%f %n", &value, &chars_read);
if ((ret == 1) && !str[chars_read])
{
struct menu_state *menu_st = menu_state_get_ptr();
const char *label = menu_st->input_dialog_kb_label_setting;
if (!string_is_empty(label))
{
rarch_setting_t *setting = NULL;
if ((setting = menu_setting_find(label)))
setting_set_with_string_representation(setting, str);
}
}
}
menu_input_dialog_end();
}
static void menu_input_st_string_cb(void *userdata, const char *str)
{
if (str && *str)
{
struct menu_state *menu_st = menu_state_get_ptr();
const char *label = menu_st->input_dialog_kb_label_setting;
if (!string_is_empty(label))
{
rarch_setting_t *setting = NULL;
if ((setting = menu_setting_find(label)))
{
if (setting->value.target.string)
strlcpy(setting->value.target.string, str, setting->size);
if (setting->change_handler)
setting->change_handler(setting);
menu_setting_generic(setting, 0, false);
}
}
}
menu_input_dialog_end();
}
static int setting_generic_action_ok_linefeed(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
menu_input_ctx_line_t line;
input_keyboard_line_complete_t cb = NULL;
if (!setting)
return -1;
(void)wraparound;
switch (setting->type)
{
case ST_SIZE:
case ST_UINT:
cb = menu_input_st_uint_cb;
break;
case ST_INT:
cb = menu_input_st_int_cb;
break;
case ST_FLOAT:
cb = menu_input_st_float_cb;
break;
case ST_STRING:
case ST_STRING_OPTIONS:
cb = menu_input_st_string_cb;
break;
default:
break;
}
line.label = setting->short_description;
line.label_setting = setting->name;
line.type = 0;
line.idx = 0;
line.cb = cb;
if (!menu_input_dialog_start(&line))
return -1;
return 0;
}
static int setting_string_action_start_generic(rarch_setting_t *setting)
{
if (!setting)
return -1;
setting->value.target.string[0] = '\0';
return 0;
}
static void setting_add_special_callbacks(
rarch_setting_t **list,
rarch_setting_info_t *list_info,
unsigned values)
{
unsigned idx = list_info->index - 1;
if (values & SD_FLAG_ALLOW_INPUT)
{
(*list)[idx].action_ok = setting_generic_action_ok_linefeed;
(*list)[idx].action_select = setting_generic_action_ok_linefeed;
switch ((*list)[idx].type)
{
case ST_STRING:
(*list)[idx].action_start = setting_string_action_start_generic;
/* fall-through */
case ST_SIZE:
case ST_UINT:
case ST_INT:
case ST_FLOAT:
(*list)[idx].action_cancel = NULL;
break;
default:
break;
}
}
}
static bool SETTINGS_LIST_APPEND_internal(
rarch_setting_t **list,
rarch_setting_info_t *list_info)
{
unsigned new_size = list_info->size * 2;
rarch_setting_t *list_settings = (rarch_setting_t*)
realloc(*list, sizeof(rarch_setting_t) * new_size);
if (!list_settings)
return false;
list_info->size = new_size;
*list = list_settings;
return true;
}
static int setting_bind_action_ok(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
if (!menu_input_key_bind_set_mode(MENU_INPUT_BINDS_CTL_BIND_SINGLE, setting))
return -1;
return 0;
}
static int setting_int_action_right_default(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
if (!setting)
return -1;
*setting->value.target.integer =
*setting->value.target.integer + setting->step;
if (setting->flags & SD_FLAG_ENFORCE_MAXRANGE)
{
float max = setting->max;
if (*setting->value.target.integer > max)
{
settings_t *settings = config_get_ptr();
float min = setting->min;
if (settings && settings->bools.menu_navigation_wraparound_enable)
*setting->value.target.integer = min;
else
*setting->value.target.integer = max;
}
}
return 0;
}
static int setting_bind_action_start(rarch_setting_t *setting)
{
unsigned bind_type;
struct retro_keybind *keybind = NULL;
struct retro_keybind *def_binds = (struct retro_keybind *)retro_keybinds_1;
if (!setting)
return -1;
if (!(keybind = (struct retro_keybind*)setting->value.target.keybind))
return -1;
keybind->joykey = NO_BTN;
keybind->joyaxis = AXIS_NONE;
/* Clear old mapping bit */
input_keyboard_mapping_bits(0, keybind->key);
if (setting->index_offset)
def_binds = (struct retro_keybind*)retro_keybinds_rest;
bind_type = setting->bind_type;
keybind->key = def_binds[bind_type - MENU_SETTINGS_BIND_BEGIN].key;
keybind->mbutton = def_binds[bind_type - MENU_SETTINGS_BIND_BEGIN].mbutton;
/* Store new mapping bit */
input_keyboard_mapping_bits(1, keybind->key);
return 0;
}
static void setting_get_string_representation_hex_and_uint(
rarch_setting_t *setting, char *s, size_t len)
{
if (setting)
snprintf(s, len, "%u (%08X)",
*setting->value.target.unsigned_integer,
*setting->value.target.unsigned_integer);
}
static void setting_get_string_representation_uint(rarch_setting_t *setting,
char *s, size_t len)
{
if (setting)
snprintf(s, len, "%u",
*setting->value.target.unsigned_integer);
}
#if defined(HAVE_NETWORKING)
static void setting_get_string_representation_color_rgb(rarch_setting_t *setting,
char *s, size_t len)
{
if (setting)
snprintf(s, len, "#%06X",
*setting->value.target.unsigned_integer & 0xFFFFFF);
}
#endif
static void setting_get_string_representation_size_in_mb(
rarch_setting_t *setting, char *s, size_t len)
{
if (setting)
snprintf(s, len, "%" PRI_SIZET,
(*setting->value.target.sizet) / (1024 * 1024));
}
#ifdef HAVE_CHEATS
static void setting_get_string_representation_uint_as_enum(
rarch_setting_t *setting, char *s, size_t len)
{
if (setting)
strlcpy(s,
msg_hash_to_str((enum msg_hash_enums)(
setting->index_offset+(
*setting->value.target.unsigned_integer))), len);
}
#endif
static float recalc_step_based_on_length_of_action(rarch_setting_t *setting)
{
float step = setting->step;
struct menu_state *menu_st = menu_state_get_ptr();
retro_time_t action_press_time = menu_st->action_press_time;
if (action_press_time > _21_SECONDS)
return step * 1000000.0f;
else if (action_press_time > _18_SECONDS)
return step * 100000.0f;
else if (action_press_time > _15_SECONDS)
return step * 10000.0f;
else if (action_press_time > _12_SECONDS)
return step * 1000.0f;
else if (action_press_time > _9_SECONDS)
return step * 100.0f;
else if (action_press_time > _6_SECONDS)
return step * 10.0f;
else if (action_press_time > _3_SECONDS)
return step * 5.0f;
return step;
}
static int setting_uint_action_left_default(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
bool overflowed = false;
float step = 0.0f;
if (!setting)
return -1;
step = recalc_step_based_on_length_of_action(setting);
if (step > *setting->value.target.unsigned_integer)
overflowed = true;
else
*setting->value.target.unsigned_integer =
*setting->value.target.unsigned_integer - step;
if (setting->flags & SD_FLAG_ENFORCE_MINRANGE)
{
float min = setting->min;
if (overflowed || *setting->value.target.unsigned_integer < min)
{
settings_t *settings = config_get_ptr();
if (settings &&
settings->bools.menu_navigation_wraparound_enable)
{
float max = setting->max;
*setting->value.target.unsigned_integer = max;
}
else
*setting->value.target.unsigned_integer = min;
}
}
return 0;
}
static int setting_uint_action_right_default(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
float step = 0.0f;
if (!setting)
return -1;
step =
recalc_step_based_on_length_of_action(setting);
*setting->value.target.unsigned_integer =
*setting->value.target.unsigned_integer + step;
if (setting->flags & SD_FLAG_ENFORCE_MAXRANGE)
{
float max = setting->max;
if (*setting->value.target.unsigned_integer > max)
{
settings_t *settings = config_get_ptr();
float min = setting->min;
if (settings && settings->bools.menu_navigation_wraparound_enable)
*setting->value.target.unsigned_integer = min;
else
*setting->value.target.unsigned_integer = max;
}
}
return 0;
}
static int setting_bool_action_right_with_refresh(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
struct menu_state *menu_st = menu_state_get_ptr();
if (*setting->value.target.boolean)
*setting->value.target.boolean = false;
else
*setting->value.target.boolean = true;
if (setting->change_handler)
setting->change_handler(setting);
menu_st->flags |= MENU_ST_FLAG_PREVENT_POPULATE
| MENU_ST_FLAG_ENTRIES_NEED_REFRESH;
return 0;
}
static int setting_uint_action_right_with_refresh(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
int retval = setting_uint_action_right_default(setting, idx, wraparound);
struct menu_state *menu_st = menu_state_get_ptr();
menu_st->flags |= MENU_ST_FLAG_PREVENT_POPULATE
| MENU_ST_FLAG_ENTRIES_NEED_REFRESH;
return retval;
}
int setting_bool_action_left_with_refresh(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
struct menu_state *menu_st = menu_state_get_ptr();
if (*setting->value.target.boolean)
*setting->value.target.boolean = false;
else
*setting->value.target.boolean = true;
if (setting->change_handler)
setting->change_handler(setting);
menu_st->flags |= MENU_ST_FLAG_PREVENT_POPULATE
| MENU_ST_FLAG_ENTRIES_NEED_REFRESH;
return 0;
}
int setting_uint_action_left_with_refresh(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
struct menu_state *menu_st = menu_state_get_ptr();
int retval = setting_uint_action_left_default(
setting, idx, wraparound);
menu_st->flags |= MENU_ST_FLAG_PREVENT_POPULATE
| MENU_ST_FLAG_ENTRIES_NEED_REFRESH;
return retval;
}
static int setting_size_action_left_default(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
bool overflowed = false;
float step = 0.0f;
if (!setting)
return -1;
step = recalc_step_based_on_length_of_action(setting);
if (!(overflowed = step > *setting->value.target.sizet))
*setting->value.target.sizet = *setting->value.target.sizet - step;
if (setting->flags & SD_FLAG_ENFORCE_MINRANGE)
{
float min = setting->min;
if (overflowed || *setting->value.target.sizet < min)
{
settings_t *settings = config_get_ptr();
float max = setting->max;
if (settings && settings->bools.menu_navigation_wraparound_enable)
*setting->value.target.sizet = max;
else
*setting->value.target.sizet = min;
}
}
return 0;
}
static int setting_size_action_right_default(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
float step = 0.0f;
if (!setting)
return -1;
step = recalc_step_based_on_length_of_action(setting);
*setting->value.target.sizet =
*setting->value.target.sizet + step;
if (setting->flags & SD_FLAG_ENFORCE_MAXRANGE)
{
float max = setting->max;
if (*setting->value.target.sizet > max)
{
settings_t *settings = config_get_ptr();
float min = setting->min;
if (settings && settings->bools.menu_navigation_wraparound_enable)
*setting->value.target.sizet = min;
else
*setting->value.target.sizet = max;
}
}
return 0;
}
static int setting_generic_action_ok_default(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
if (!setting)
return -1;
if (setting->cmd_trigger_idx != CMD_EVENT_NONE)
setting->flags |= SD_FLAG_CMD_TRIGGER_EVENT_TRIGGERED;
return 0;
}
void setting_generic_handle_change(rarch_setting_t *setting)
{
settings_t *settings = config_get_ptr();
settings->modified = true;
if (setting->change_handler)
setting->change_handler(setting);
if ( setting->cmd_trigger_idx
&& !(setting->flags & SD_FLAG_CMD_TRIGGER_EVENT_TRIGGERED))
command_event(setting->cmd_trigger_idx, NULL);
}
static void setting_get_string_representation_int_gpu_index(rarch_setting_t *setting,
char *s, size_t len)
{
if (setting)
{
struct string_list *list = video_driver_get_gpu_api_devices(video_context_driver_get_api());
size_t _len = snprintf(s, len, "%d", *setting->value.target.integer);
if (list && (*setting->value.target.integer < (int)list->size) && !string_is_empty(list->elems[*setting->value.target.integer].data))
{
s[ _len] = ' ';
s[++_len] = '-';
s[++_len] = ' ';
s[++_len] = '\0';
strlcpy(s + _len, list->elems[*setting->value.target.integer].data, len - _len);
}
}
}
static void setting_get_string_representation_int(
rarch_setting_t *setting,
char *s, size_t len)
{
if (setting)
snprintf(s, len, "%d", *setting->value.target.integer);
}
static int setting_fraction_action_left_default(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
if (!setting)
return -1;
*setting->value.target.fraction =
*setting->value.target.fraction - setting->step;
if (setting->flags & SD_FLAG_ENFORCE_MINRANGE)
{
float min = setting->min;
float half_step = setting->step * 0.5f;
if (*setting->value.target.fraction < min - half_step)
{
settings_t *settings = config_get_ptr();
float max = setting->max;
if (settings && settings->bools.menu_navigation_wraparound_enable)
*setting->value.target.fraction = max;
else
*setting->value.target.fraction = min;
}
}
return 0;
}
static int setting_fraction_action_right_default(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
if (!setting)
return -1;
*setting->value.target.fraction =
*setting->value.target.fraction + setting->step;
if (setting->flags & SD_FLAG_ENFORCE_MAXRANGE)
{
float max = setting->max;
if (*setting->value.target.fraction > max)
{
settings_t *settings = config_get_ptr();
float min = setting->min;
if (settings && settings->bools.menu_navigation_wraparound_enable)
*setting->value.target.fraction = min;
else
*setting->value.target.fraction = max;
}
}
return 0;
}
/**
* setting_reset_setting:
* @setting : pointer to setting
*
* Reset a setting's value to its defaults.
**/
static void setting_reset_setting(rarch_setting_t* setting)
{
if (!setting)
return;
switch (setting->type)
{
case ST_BOOL:
*setting->value.target.boolean = setting->default_value.boolean;
break;
case ST_INT:
*setting->value.target.integer = setting->default_value.integer;
break;
case ST_UINT:
*setting->value.target.unsigned_integer = setting->default_value.unsigned_integer;
break;
case ST_SIZE:
*setting->value.target.sizet = setting->default_value.sizet;
break;
case ST_FLOAT:
*setting->value.target.fraction = setting->default_value.fraction;
break;
case ST_BIND:
*setting->value.target.keybind = *setting->default_value.keybind;
break;
case ST_STRING:
case ST_STRING_OPTIONS:
case ST_PATH:
case ST_DIR:
if (setting->default_value.string)
{
if (setting->type == ST_STRING)
{
if (setting->value.target.string)
strlcpy(setting->value.target.string,
setting->default_value.string,
setting->size);
if (setting->change_handler)
setting->change_handler(setting);
}
else
fill_pathname_expand_special(setting->value.target.string,
setting->default_value.string, setting->size);
}
break;
default:
break;
}
if (setting->change_handler)
setting->change_handler(setting);
}
static int setting_generic_action_start_default(rarch_setting_t *setting)
{
struct menu_state *menu_st = menu_state_get_ptr();
if (!setting)
return -1;
setting_reset_setting(setting);
menu_st->flags |= MENU_ST_FLAG_PREVENT_POPULATE
| MENU_ST_FLAG_ENTRIES_NEED_REFRESH;
return 0;
}
static void setting_get_string_representation_default(rarch_setting_t *setting,
char *s, size_t len)
{
s[0] = '\0';
}
/**
* setting_get_string_representation_st_bool:
* @setting : pointer to setting
* @s : string for the type to be represented on-screen as
* a label.
* @len : size of @s
*
* Set a settings' label value. The setting is of type ST_BOOL.
**/
static void setting_get_string_representation_st_bool(rarch_setting_t *setting,
char *s, size_t len)
{
if (setting)
strlcpy(s, *setting->value.target.boolean
? setting->boolean.on_label
: setting->boolean.off_label,
len);
}
/**
* setting_get_string_representation_st_float:
* @setting : pointer to setting
* @s : string for the type to be represented on-screen as
* a label.
* @len : size of @s
*
* Set a settings' label value. The setting is of type ST_FLOAT.
**/
static void setting_get_string_representation_st_float(rarch_setting_t *setting,
char *s, size_t len)
{
if (setting)
snprintf(s, len, setting->rounding_fraction,
*setting->value.target.fraction);
}
static void setting_get_string_representation_st_dir(rarch_setting_t *setting,
char *s, size_t len)
{
if (setting)
#if IOS
{
if (*setting->value.target.string)
fill_pathname_abbreviate_special(s, setting->value.target.string, len);
else
strlcpy(s, setting->dir.empty_path, len);
}
#else
strlcpy(s,
*setting->value.target.string
? setting->value.target.string
: setting->dir.empty_path,
len);
#endif
}
static void setting_get_string_representation_st_path(rarch_setting_t *setting,
char *s, size_t len)
{
if (setting)
#if IOS
fill_pathname_abbreviate_special(s, path_basename(setting->value.target.string), len);
#else
fill_pathname(s, path_basename(setting->value.target.string),
"", len);
#endif
}
static void setting_get_string_representation_st_string(rarch_setting_t *setting,
char *s, size_t len)
{
if (setting)
strlcpy(s, setting->value.target.string, len);
}
static void setting_get_string_representation_st_bind(rarch_setting_t *setting,
char *s, size_t len)
{
unsigned index_offset = 0;
const struct retro_keybind* keybind = NULL;
const struct retro_keybind* auto_bind = NULL;
settings_t *settings = config_get_ptr();
if (!setting)
return;
index_offset = setting->index_offset;
keybind = (const struct retro_keybind*)setting->value.target.keybind;
auto_bind = (const struct retro_keybind*)
input_config_get_bind_auto(index_offset, keybind->id);
input_config_get_bind_string(settings, s, keybind, auto_bind, len);
}
static int setting_action_action_ok(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
if (!setting)
return -1;
if (setting->cmd_trigger_idx != CMD_EVENT_NONE)
command_event(setting->cmd_trigger_idx, NULL);
return 0;
}
/**
* setting_action_setting:
* @name : Name of setting.
* @short_description : Short description of setting.
* @group : Group that the setting belongs to.
* @subgroup : Subgroup that the setting belongs to.
*
* Initializes a setting of type ST_ACTION.
*
* Returns: setting of type ST_ACTION.
**/
static rarch_setting_t setting_action_setting(const char* name,
const char* short_description,
const char *group, const char *subgroup,
const char *parent_group,
bool dont_use_enum_idx)
{
rarch_setting_t result;
result.enum_idx = MSG_UNKNOWN;
result.type = ST_ACTION;
result.size = 0;
result.name = name;
result.short_description = short_description;
result.group = group;
result.subgroup = subgroup;
result.parent_group = parent_group;
result.values = NULL;
result.index = 0;
result.index_offset = 0;
result.offset_by = 0;
result.min = 0.0;
result.max = 0.0;
result.flags = 0;
result.free_flags = 0;
result.change_handler = NULL;
result.read_handler = NULL;
result.action_start = NULL;
result.action_left = NULL;
result.action_right = NULL;
result.action_up = NULL;
result.action_down = NULL;
result.action_cancel = NULL;
result.action_ok = setting_action_action_ok;
result.action_select = setting_action_action_ok;
result.get_string_representation = &setting_get_string_representation_default;
result.bind_type = 0;
result.browser_selection_type = ST_NONE;
result.step = 0.0f;
result.rounding_fraction = NULL;
result.cmd_trigger_idx = CMD_EVENT_NONE;
if (dont_use_enum_idx)
result.flags |= SD_FLAG_DONT_USE_ENUM_IDX_REPRESENTATION;
return result;
}
/**
* setting_group_setting:
* @type : type of settting.
* @name : name of setting.
*
* Initializes a setting of type ST_GROUP.
*
* Returns: setting of type ST_GROUP.
**/
static rarch_setting_t setting_group_setting(
enum setting_type type, const char* name,
const char *parent_group)
{
rarch_setting_t result;
result.enum_idx = MSG_UNKNOWN;
result.type = type;
result.size = 0;
result.name = name;
result.short_description = name;
result.group = NULL;
result.subgroup = NULL;
result.parent_group = parent_group;
result.values = NULL;
result.index = 0;
result.index_offset = 0;
result.offset_by = 0;
result.min = 0.0;
result.max = 0.0;
result.flags = 0;
result.free_flags = 0;
result.change_handler = NULL;
result.read_handler = NULL;
result.action_start = NULL;
result.action_left = NULL;
result.action_right = NULL;
result.action_up = NULL;
result.action_down = NULL;
result.action_cancel = NULL;
result.action_ok = NULL;
result.action_select = NULL;
result.get_string_representation = &setting_get_string_representation_default;
result.bind_type = 0;
result.browser_selection_type = ST_NONE;
result.step = 0.0f;
result.rounding_fraction = NULL;
result.cmd_trigger_idx = CMD_EVENT_NONE;
return result;
}
/**
* setting_float_setting:
* @name : name of setting.
* @short_description : Short description of setting.
* @target : Target of float setting.
* @default_value : Default value (in float).
* @rounding : Rounding (for float-to-string representation).
* @group : Group that the setting belongs to.
* @subgroup : Subgroup that the setting belongs to.
* @change_handler : Function callback for change handler function pointer.
* @read_handler : Function callback for read handler function pointer.
*
* Initializes a setting of type ST_FLOAT.
*
* Returns: setting of type ST_FLOAT.
**/
static rarch_setting_t setting_float_setting(const char* name,
const char* short_description, float* target, float default_value,
const char *rounding, const char *group, const char *subgroup,
const char *parent_group,
change_handler_t change_handler, change_handler_t read_handler,
bool dont_use_enum_idx)
{
rarch_setting_t result;
result.enum_idx = MSG_UNKNOWN;
result.type = ST_FLOAT;
result.size = sizeof(float);
result.name = name;
result.short_description = short_description;
result.group = group;
result.subgroup = subgroup;
result.parent_group = parent_group;
result.values = NULL;
result.index = 0;
result.index_offset = 0;
result.offset_by = 0;
result.min = 0.0;
result.max = 0.0;
result.flags = 0;
result.free_flags = 0;
result.change_handler = change_handler;
result.read_handler = read_handler;
result.action_start = setting_generic_action_start_default;
result.action_left = setting_fraction_action_left_default;
result.action_right = setting_fraction_action_right_default;
result.action_up = NULL;
result.action_down = NULL;
result.action_cancel = NULL;
result.action_ok = setting_generic_action_ok_default;
result.action_select = setting_generic_action_ok_default;
result.get_string_representation = &setting_get_string_representation_st_float;
result.bind_type = 0;
result.browser_selection_type = ST_NONE;
result.step = 0.0f;
result.rounding_fraction = rounding;
result.value.target.fraction = target;
result.original_value.fraction = *target;
result.default_value.fraction = default_value;
result.cmd_trigger_idx = CMD_EVENT_NONE;
if (dont_use_enum_idx)
result.flags |= SD_FLAG_DONT_USE_ENUM_IDX_REPRESENTATION;
return result;
}
/**
* setting_uint_setting:
* @name : name of setting.
* @short_description : Short description of setting.
* @target : Target of unsigned integer setting.
* @default_value : Default value (in unsigned integer format).
* @group : Group that the setting belongs to.
* @subgroup : Subgroup that the setting belongs to.
* @change_handler : Function callback for change handler function pointer.
* @read_handler : Function callback for read handler function pointer.
*
* Initializes a setting of type ST_UINT.
*
* Returns: setting of type ST_UINT.
**/
static rarch_setting_t setting_uint_setting(const char* name,
const char* short_description, unsigned int* target,
unsigned int default_value,
const char *group, const char *subgroup, const char *parent_group,
change_handler_t change_handler, change_handler_t read_handler,
bool dont_use_enum_idx)
{
rarch_setting_t result;
result.enum_idx = MSG_UNKNOWN;
result.type = ST_UINT;
result.size = sizeof(unsigned int);
result.name = name;
result.short_description = short_description;
result.group = group;
result.subgroup = subgroup;
result.parent_group = parent_group;
result.values = NULL;
result.index = 0;
result.index_offset = 0;
result.offset_by = 0;
result.min = 0.0;
result.max = 0.0;
result.flags = 0;
result.free_flags = 0;
result.change_handler = change_handler;
result.read_handler = read_handler;
result.action_start = setting_generic_action_start_default;
result.action_left = setting_uint_action_left_default;
result.action_right = setting_uint_action_right_default;
result.action_up = NULL;
result.action_down = NULL;
result.action_cancel = NULL;
result.action_ok = setting_generic_action_ok_default;
result.action_select = setting_generic_action_ok_default;
result.get_string_representation = &setting_get_string_representation_uint;
result.bind_type = 0;
result.browser_selection_type = ST_NONE;
result.step = 0.0f;
result.rounding_fraction = NULL;
result.value.target.unsigned_integer = target;
result.original_value.unsigned_integer = *target;
result.default_value.unsigned_integer = default_value;
result.cmd_trigger_idx = CMD_EVENT_NONE;
if (dont_use_enum_idx)
result.flags |= SD_FLAG_DONT_USE_ENUM_IDX_REPRESENTATION;
return result;
}
/**
* setting_size_setting:
* @name : name of setting.
* @short_description : Short description of setting.
* @target : Target of size_t setting.
* @default_value : Default value (in size_t format).
* @group : Group that the setting belongs to.
* @subgroup : Subgroup that the setting belongs to.
* @change_handler : Function callback for change handler function pointer.
* @read_handler : Function callback for read handler function pointer.
* @dont_use_enum_idx : Boolean indicating whether or not to use the enum idx
* @string_representation_handler : Function callback for converting the setting to a string
*
* Initializes a setting of type ST_SIZE.
*
* Returns: setting of type ST_SIZE.
**/
static rarch_setting_t setting_size_setting(const char* name,
const char* short_description, size_t* target,
size_t default_value,
const char *group, const char *subgroup, const char *parent_group,
change_handler_t change_handler, change_handler_t read_handler,
bool dont_use_enum_idx, get_string_representation_t string_representation_handler)
{
rarch_setting_t result;
result.enum_idx = MSG_UNKNOWN;
result.type = ST_SIZE;
result.size = sizeof(size_t);
result.name = name;
result.short_description = short_description;
result.group = group;
result.subgroup = subgroup;
result.parent_group = parent_group;
result.values = NULL;
result.index = 0;
result.index_offset = 0;
result.offset_by = 0;
result.min = 0.0;
result.max = 0.0;
result.flags = 0;
result.free_flags = 0;
result.change_handler = change_handler;
result.read_handler = read_handler;
result.action_start = setting_generic_action_start_default;
result.action_left = setting_size_action_left_default;
result.action_right = setting_size_action_right_default;
result.action_up = NULL;
result.action_down = NULL;
result.action_cancel = NULL;
result.action_ok = setting_generic_action_ok_default;
result.action_select = setting_generic_action_ok_default;
result.get_string_representation = string_representation_handler;
result.bind_type = 0;
result.browser_selection_type = ST_NONE;
result.step = 0.0f;
result.rounding_fraction = NULL;
result.value.target.sizet = target;
result.original_value.sizet = *target;
result.default_value.sizet = default_value;
result.cmd_trigger_idx = CMD_EVENT_NONE;
if (dont_use_enum_idx)
result.flags |= SD_FLAG_DONT_USE_ENUM_IDX_REPRESENTATION;
return result;
}
/**
* setting_bind_setting:
* @name : name of setting.
* @short_description : Short description of setting.
* @target : Target of bind setting.
* @idx : Index of bind setting.
* @idx_offset : Index offset of bind setting.
* @default_value : Default value (in bind format).
* @group : Group that the setting belongs to.
* @subgroup : Subgroup that the setting belongs to.
*
* Initializes a setting of type ST_BIND.
*
* Returns: setting of type ST_BIND.
**/
static rarch_setting_t setting_bind_setting(const char* name,
const char* short_description, struct retro_keybind* target,
uint32_t idx, uint32_t idx_offset,
const struct retro_keybind* default_value,
const char *group, const char *subgroup,
const char *parent_group,
bool dont_use_enum_idx)
{
rarch_setting_t result;
result.enum_idx = MSG_UNKNOWN;
result.type = ST_BIND;
result.size = 0;
result.name = name;
result.short_description = short_description;
result.group = group;
result.subgroup = subgroup;
result.parent_group = parent_group;
result.values = NULL;
result.index = idx;
result.index_offset = idx_offset;
result.offset_by = 0;
result.min = 0.0;
result.max = 0.0;
result.flags = 0;
result.free_flags = 0;
result.change_handler = NULL;
result.read_handler = NULL;
result.action_start = setting_bind_action_start;
result.action_left = NULL;
result.action_right = NULL;
result.action_up = NULL;
result.action_down = NULL;
result.action_cancel = NULL;
result.action_ok = setting_bind_action_ok;
result.action_select = setting_bind_action_ok;
result.get_string_representation = &setting_get_string_representation_st_bind;
result.bind_type = 0;
result.browser_selection_type = ST_NONE;
result.step = 0.0f;
result.rounding_fraction = NULL;
result.value.target.keybind = target;
result.default_value.keybind = default_value;
result.cmd_trigger_idx = CMD_EVENT_NONE;
if (dont_use_enum_idx)
result.flags |= SD_FLAG_DONT_USE_ENUM_IDX_REPRESENTATION;
return result;
}
static int setting_int_action_left_default(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
if (!setting)
return -1;
*setting->value.target.integer = *setting->value.target.integer - setting->step;
if (setting->flags & SD_FLAG_ENFORCE_MINRANGE)
{
float min = setting->min;
if (*setting->value.target.integer < min)
{
settings_t *settings = config_get_ptr();
float max = setting->max;
if ( settings
&& settings->bools.menu_navigation_wraparound_enable)
*setting->value.target.integer = max;
else
*setting->value.target.integer = min;
}
}
return 0;
}
static int setting_bool_action_ok_default(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
if (!setting)
return -1;
if (*setting->value.target.boolean)
*setting->value.target.boolean = false;
else
*setting->value.target.boolean = true;
if (setting->change_handler)
setting->change_handler(setting);
return 0;
}
/**
* setting_string_setting:
* @type : type of setting.
* @name : name of setting.
* @short_description : Short description of setting.
* @target : Target of string setting.
* @size : Size of string setting.
* @default_value : Default value (in string format).
* @empty : TODO/FIXME: ???
* @group : Group that the setting belongs to.
* @subgroup : Subgroup that the setting belongs to.
* @change_handler : Function callback for change handler function pointer.
* @read_handler : Function callback for read handler function pointer.
*
* Initializes a string setting (of type @type).
*
* Returns: String setting of type @type.
**/
static rarch_setting_t setting_string_setting(enum setting_type type,
const char* name, const char* short_description, char* target,
unsigned size, const char* default_value, const char *empty,
const char *group, const char *subgroup, const char *parent_group,
change_handler_t change_handler,
change_handler_t read_handler,
bool dont_use_enum_idx)
{
rarch_setting_t result;
result.enum_idx = MSG_UNKNOWN;
result.type = type;
result.size = size;
result.name = name;
result.short_description = short_description;
result.group = group;
result.subgroup = subgroup;
result.parent_group = parent_group;
result.values = NULL;
result.index = 0;
result.index_offset = 0;
result.offset_by = 0;
result.min = 0.0;
result.max = 0.0;
result.flags = 0;
result.free_flags = 0;
result.change_handler = change_handler;
result.read_handler = read_handler;
result.action_start = NULL;
result.action_left = NULL;
result.action_right = NULL;
result.action_up = NULL;
result.action_down = NULL;
result.action_cancel = NULL;
result.action_ok = NULL;
result.action_select = NULL;
result.get_string_representation = &setting_get_string_representation_st_string;
result.bind_type = 0;
result.browser_selection_type = ST_NONE;
result.step = 0.0f;
result.rounding_fraction = NULL;
result.dir.empty_path = empty;
result.value.target.string = target;
result.default_value.string = default_value;
result.cmd_trigger_idx = CMD_EVENT_NONE;
switch (type)
{
case ST_DIR:
result.action_start = setting_string_action_start_generic;
result.browser_selection_type = ST_DIR;
result.get_string_representation = &setting_get_string_representation_st_dir;
break;
case ST_PATH:
result.action_start = setting_string_action_start_generic;
result.browser_selection_type = ST_PATH;
result.get_string_representation = &setting_get_string_representation_st_path;
break;
default:
break;
}
if (dont_use_enum_idx)
result.flags |= SD_FLAG_DONT_USE_ENUM_IDX_REPRESENTATION;
return result;
}
/**
* setting_string_setting_options:
* @type : type of settting.
* @name : name of setting.
* @short_description : Short description of setting.
* @target : Target of bind setting.
* @size : Size of string setting.
* @default_value : Default value.
* @empty : N/A.
* @values : Values, separated by a delimiter.
* @group : Group that the setting belongs to.
* @subgroup : Subgroup that the setting belongs to.
* @change_handler : Function callback for change handler function pointer.
* @read_handler : Function callback for read handler function pointer.
*
* Initializes a string options list setting.
*
* Returns: string option list setting.
**/
static rarch_setting_t setting_string_setting_options(enum setting_type type,
const char* name, const char* short_description, char* target,
unsigned size, const char* default_value,
const char *empty, const char *values,
const char *group, const char *subgroup, const char *parent_group,
change_handler_t change_handler, change_handler_t read_handler,
bool dont_use_enum_idx)
{
rarch_setting_t result = setting_string_setting(type, name,
short_description, target, size, default_value, empty, group,
subgroup, parent_group, change_handler, read_handler,
dont_use_enum_idx);
result.action_start = setting_generic_action_start_default;
result.parent_group = parent_group;
result.values = values;
return result;
}
/**
* setting_subgroup_setting:
* @type : type of settting.
* @name : name of setting.
* @parent_name : group that the subgroup setting belongs to.
*
* Initializes a setting of type ST_SUBGROUP.
*
* Returns: setting of type ST_SUBGROUP.
**/
static rarch_setting_t setting_subgroup_setting(enum setting_type type,
const char* name, const char *parent_name, const char *parent_group,
bool dont_use_enum_idx)
{
rarch_setting_t result;
result.enum_idx = MSG_UNKNOWN;
result.type = type;
result.size = 0;
result.name = name;
result.short_description = name;
result.group = parent_name;
result.parent_group = parent_group;
result.values = NULL;
result.subgroup = NULL;
result.index = 0;
result.index_offset = 0;
result.offset_by = 0;
result.min = 0.0;
result.max = 0.0;
result.flags = 0;
result.free_flags = 0;
result.change_handler = NULL;
result.read_handler = NULL;
result.action_start = NULL;
result.action_left = NULL;
result.action_right = NULL;
result.action_up = NULL;
result.action_down = NULL;
result.action_cancel = NULL;
result.action_ok = NULL;
result.action_select = NULL;
result.get_string_representation = &setting_get_string_representation_default;
result.bind_type = 0;
result.browser_selection_type = ST_NONE;
result.step = 0.0f;
result.rounding_fraction = NULL;
result.cmd_trigger_idx = CMD_EVENT_NONE;
if (dont_use_enum_idx)
result.flags |= SD_FLAG_DONT_USE_ENUM_IDX_REPRESENTATION;
return result;
}
/**
* setting_bool_setting:
* @name : name of setting.
* @short_description : Short description of setting.
* @target : Target of bool setting.
* @default_value : Default value (in bool format).
* @off : String value for "Off" label.
* @on : String value for "On" label.
* @group : Group that the setting belongs to.
* @subgroup : Subgroup that the setting belongs to.
* @change_handler : Function callback for change handler function pointer.
* @read_handler : Function callback for read handler function pointer.
*
* Initializes a setting of type ST_BOOL.
*
* Returns: setting of type ST_BOOL.
**/
static rarch_setting_t setting_bool_setting(const char* name,
const char* short_description, bool* target, bool default_value,
const char *off, const char *on,
const char *group, const char *subgroup, const char *parent_group,
change_handler_t change_handler, change_handler_t read_handler,
bool dont_use_enum_idx)
{
rarch_setting_t result;
result.enum_idx = MSG_UNKNOWN;
result.type = ST_BOOL;
result.size = sizeof(bool);
result.name = name;
result.short_description = short_description;
result.group = group;
result.subgroup = subgroup;
result.parent_group = parent_group;
result.values = NULL;
result.index = 0;
result.index_offset = 0;
result.offset_by = 0;
result.min = 0.0;
result.max = 0.0;
result.flags = 0;
result.free_flags = 0;
result.change_handler = change_handler;
result.read_handler = read_handler;
result.action_start = setting_generic_action_start_default;
result.action_left = setting_bool_action_ok_default;
result.action_right = setting_bool_action_ok_default;
result.action_up = NULL;
result.action_down = NULL;
result.action_cancel = NULL;
result.action_ok = setting_bool_action_ok_default;
result.action_select = setting_generic_action_ok_default;
result.get_string_representation = &setting_get_string_representation_st_bool;
result.bind_type = 0;
result.browser_selection_type = ST_NONE;
result.step = 0.0f;
result.rounding_fraction = NULL;
result.value.target.boolean = target;
result.original_value.boolean = *target;
result.default_value.boolean = default_value;
result.boolean.off_label = off;
result.boolean.on_label = on;
result.cmd_trigger_idx = CMD_EVENT_NONE;
if (dont_use_enum_idx)
result.flags |= SD_FLAG_DONT_USE_ENUM_IDX_REPRESENTATION;
return result;
}
/**
* setting_int_setting:
* @name : name of setting.
* @short_description : Short description of setting.
* @target : Target of signed integer setting.
* @default_value : Default value (in signed integer format).
* @group : Group that the setting belongs to.
* @subgroup : Subgroup that the setting belongs to.
* @change_handler : Function callback for change handler function pointer.
* @read_handler : Function callback for read handler function pointer.
*
* Initializes a setting of type ST_INT.
*
* Returns: setting of type ST_INT.
**/
static rarch_setting_t setting_int_setting(const char* name,
const char* short_description, int* target,
int default_value,
const char *group, const char *subgroup, const char *parent_group,
change_handler_t change_handler, change_handler_t read_handler,
bool dont_use_enum_idx)
{
rarch_setting_t result;
result.enum_idx = MSG_UNKNOWN;
result.type = ST_INT;
result.size = sizeof(int);
result.name = name;
result.short_description = short_description;
result.group = group;
result.subgroup = subgroup;
result.parent_group = parent_group;
result.values = NULL;
result.index = 0;
result.index_offset = 0;
result.offset_by = 0;
result.min = 0.0;
result.max = 0.0;
result.flags = 0;
result.free_flags = 0;
result.change_handler = change_handler;
result.read_handler = read_handler;
result.action_start = setting_generic_action_start_default;
result.action_left = setting_int_action_left_default;
result.action_right = setting_int_action_right_default;
result.action_up = NULL;
result.action_down = NULL;
result.action_cancel = NULL;
result.action_ok = setting_generic_action_ok_default;
result.action_select = setting_generic_action_ok_default;
result.get_string_representation = &setting_get_string_representation_int;
result.bind_type = 0;
result.browser_selection_type = ST_NONE;
result.step = 0.0f;
result.rounding_fraction = NULL;
result.value.target.integer = target;
result.original_value.integer = *target;
result.default_value.integer = default_value;
result.cmd_trigger_idx = CMD_EVENT_NONE;
if (dont_use_enum_idx)
result.flags |= SD_FLAG_DONT_USE_ENUM_IDX_REPRESENTATION;
return result;
}
#ifdef HAVE_NETWORKING
static void config_bool_alt(
rarch_setting_t **list,
rarch_setting_info_t *list_info,
bool *target,
const char *name, const char *SHORT,
bool default_value,
enum msg_hash_enums off_enum_idx,
enum msg_hash_enums on_enum_idx,
rarch_setting_group_info_t *group_info,
rarch_setting_group_info_t *subgroup_info,
const char *parent_group,
change_handler_t change_handler,
change_handler_t read_handler,
uint32_t flags)
{
(*list)[list_info->index++] = setting_bool_setting(name, SHORT, target,
default_value,
msg_hash_to_str(off_enum_idx), msg_hash_to_str(on_enum_idx),
group_info->name, subgroup_info->name, parent_group,
change_handler, read_handler, true);
if (flags != SD_FLAG_NONE)
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, flags);
}
#endif
static void config_bool(
rarch_setting_t **list,
rarch_setting_info_t *list_info,
bool *target,
enum msg_hash_enums name_enum_idx,
enum msg_hash_enums SHORT_enum_idx,
bool default_value,
enum msg_hash_enums off_enum_idx,
enum msg_hash_enums on_enum_idx,
rarch_setting_group_info_t *group_info,
rarch_setting_group_info_t *subgroup_info,
const char *parent_group,
change_handler_t change_handler,
change_handler_t read_handler,
uint32_t flags)
{
(*list)[list_info->index++] = setting_bool_setting(
msg_hash_to_str(name_enum_idx),
msg_hash_to_str(SHORT_enum_idx),
target,
default_value,
msg_hash_to_str(off_enum_idx),
msg_hash_to_str(on_enum_idx),
group_info->name, subgroup_info->name, parent_group,
change_handler, read_handler, false);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_CHECKBOX;
if (flags != SD_FLAG_NONE)
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, flags);
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_IDX_PTR(list, list_info, name_enum_idx);
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_VALUE_IDX(list, list_info, SHORT_enum_idx);
}
static void config_int(
rarch_setting_t **list,
rarch_setting_info_t *list_info,
int *target,
enum msg_hash_enums name_enum_idx,
enum msg_hash_enums SHORT_enum_idx,
int default_value,
rarch_setting_group_info_t *group_info,
rarch_setting_group_info_t *subgroup_info,
const char *parent_group,
change_handler_t change_handler, change_handler_t read_handler)
{
(*list)[list_info->index++] = setting_int_setting(
msg_hash_to_str(name_enum_idx),
msg_hash_to_str(SHORT_enum_idx),
target, default_value,
group_info->name, subgroup_info->name, parent_group,
change_handler, read_handler,
false);
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_IDX_PTR(list, list_info, name_enum_idx);
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_VALUE_IDX(list, list_info, SHORT_enum_idx);
}
static void config_uint_alt(
rarch_setting_t **list,
rarch_setting_info_t *list_info,
unsigned int *target,
const char *name, const char *SHORT,
unsigned int default_value,
rarch_setting_group_info_t *group_info,
rarch_setting_group_info_t *subgroup_info,
const char *parent_group,
change_handler_t change_handler, change_handler_t read_handler)
{
(*list)[list_info->index++] = setting_uint_setting(
name, SHORT, target, default_value,
group_info->name,
subgroup_info->name, parent_group, change_handler, read_handler,
true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_SPINBOX;
}
static void config_uint(
rarch_setting_t **list,
rarch_setting_info_t *list_info,
unsigned int *target,
enum msg_hash_enums name_enum_idx,
enum msg_hash_enums SHORT_enum_idx,
unsigned int default_value,
rarch_setting_group_info_t *group_info,
rarch_setting_group_info_t *subgroup_info,
const char *parent_group,
change_handler_t change_handler, change_handler_t read_handler)
{
(*list)[list_info->index++] = setting_uint_setting (
msg_hash_to_str(name_enum_idx),
msg_hash_to_str(SHORT_enum_idx),
target, default_value,
group_info->name,
subgroup_info->name, parent_group,
change_handler, read_handler,
false);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_SPINBOX;
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_IDX_PTR(list, list_info, name_enum_idx);
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_VALUE_IDX(list, list_info, SHORT_enum_idx);
}
static void config_size(
rarch_setting_t **list,
rarch_setting_info_t *list_info,
size_t *target,
enum msg_hash_enums name_enum_idx,
enum msg_hash_enums SHORT_enum_idx,
size_t default_value,
rarch_setting_group_info_t *group_info,
rarch_setting_group_info_t *subgroup_info,
const char *parent_group,
change_handler_t change_handler, change_handler_t read_handler,
get_string_representation_t string_representation_handler)
{
(*list)[list_info->index++] = setting_size_setting (
msg_hash_to_str(name_enum_idx),
msg_hash_to_str(SHORT_enum_idx),
target, default_value,
group_info->name,
subgroup_info->name, parent_group,
change_handler, read_handler,
false, string_representation_handler);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_SIZE_SPINBOX;
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_IDX_PTR(list, list_info, name_enum_idx);
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_VALUE_IDX(list, list_info, SHORT_enum_idx);
}
static void config_float(
rarch_setting_t **list,
rarch_setting_info_t *list_info,
float *target,
enum msg_hash_enums name_enum_idx,
enum msg_hash_enums SHORT_enum_idx,
float default_value, const char *rounding,
rarch_setting_group_info_t *group_info,
rarch_setting_group_info_t *subgroup_info,
const char *parent_group,
change_handler_t change_handler, change_handler_t read_handler)
{
(*list)[list_info->index++] = setting_float_setting(
msg_hash_to_str(name_enum_idx),
msg_hash_to_str(SHORT_enum_idx), target, default_value, rounding,
group_info->name, subgroup_info->name, parent_group,
change_handler, read_handler, false);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_FLOAT_SPINBOX;
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_IDX_PTR(list, list_info, name_enum_idx);
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_VALUE_IDX(list, list_info, SHORT_enum_idx);
}
static void config_path(
rarch_setting_t **list,
rarch_setting_info_t *list_info,
char *target, size_t len,
enum msg_hash_enums name_enum_idx,
enum msg_hash_enums SHORT_enum_idx,
const char *default_value,
rarch_setting_group_info_t *group_info,
rarch_setting_group_info_t *subgroup_info,
const char *parent_group,
change_handler_t change_handler, change_handler_t read_handler)
{
(*list)[list_info->index++] = setting_string_setting(ST_PATH,
msg_hash_to_str(name_enum_idx),
msg_hash_to_str(SHORT_enum_idx),
target, (unsigned)len, default_value, "",
group_info->name, subgroup_info->name, parent_group,
change_handler, read_handler,
false);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_FILE_SELECTOR;
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_EMPTY);
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_IDX_PTR(list, list_info, name_enum_idx);
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_VALUE_IDX(list, list_info, SHORT_enum_idx);
}
static void config_dir(
rarch_setting_t **list,
rarch_setting_info_t *list_info,
char *target, size_t len,
enum msg_hash_enums name_enum_idx,
enum msg_hash_enums SHORT_enum_idx,
const char *default_value,
enum msg_hash_enums empty_enum_idx,
rarch_setting_group_info_t *group_info,
rarch_setting_group_info_t *subgroup_info,
const char *parent_group,
change_handler_t change_handler, change_handler_t read_handler)
{
(*list)[list_info->index++] = setting_string_setting(ST_DIR,
msg_hash_to_str(name_enum_idx),
msg_hash_to_str(SHORT_enum_idx),
target, (unsigned)len, default_value,
msg_hash_to_str(empty_enum_idx),
group_info->name, subgroup_info->name, parent_group,
change_handler, read_handler,
false);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_DIRECTORY_SELECTOR;
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(
list,
list_info,
SD_FLAG_ALLOW_EMPTY | SD_FLAG_PATH_DIR | SD_FLAG_BROWSER_ACTION);
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_IDX_PTR(list, list_info, name_enum_idx);
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_VALUE_IDX(list, list_info, SHORT_enum_idx);
}
static void config_string(
rarch_setting_t **list,
rarch_setting_info_t *list_info,
char *target, size_t len,
enum msg_hash_enums name_enum_idx,
enum msg_hash_enums SHORT_enum_idx,
const char *default_value,
rarch_setting_group_info_t *group_info,
rarch_setting_group_info_t *subgroup_info,
const char *parent_group,
change_handler_t change_handler, change_handler_t read_handler)
{
(*list)[list_info->index++] = setting_string_setting(ST_STRING,
msg_hash_to_str(name_enum_idx),
msg_hash_to_str(SHORT_enum_idx),
target, (unsigned)len, default_value, "",
group_info->name, subgroup_info->name, parent_group,
change_handler, read_handler, false);
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_IDX_PTR(list, list_info, name_enum_idx);
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_VALUE_IDX(list, list_info, SHORT_enum_idx);
}
static void config_string_options(
rarch_setting_t **list,
rarch_setting_info_t *list_info,
char *target, size_t len,
enum msg_hash_enums name_enum_idx,
enum msg_hash_enums SHORT_enum_idx,
const char *default_value, const char *values,
rarch_setting_group_info_t *group_info,
rarch_setting_group_info_t *subgroup_info,
const char *parent_group,
change_handler_t change_handler, change_handler_t read_handler)
{
(*list)[list_info->index++] = setting_string_setting_options(
ST_STRING_OPTIONS,
msg_hash_to_str(name_enum_idx),
msg_hash_to_str(SHORT_enum_idx),
target, (unsigned)len, default_value, "", values,
group_info->name, subgroup_info->name, parent_group,
change_handler, read_handler, false);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_STRING_COMBOBOX;
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_IDX_PTR(list, list_info, name_enum_idx);
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_VALUE_IDX(list, list_info, SHORT_enum_idx);
/* Request values to be freed later */
SETTINGS_DATA_LIST_CURRENT_ADD_FREE_FLAGS(list, list_info, SD_FREE_FLAG_VALUES);
}
/* Please strdup() NAME and SHORT */
static void config_bind_alt(
rarch_setting_t **list,
rarch_setting_info_t *list_info,
struct retro_keybind *target,
uint32_t player, uint32_t player_offset,
const char *name, const char *SHORT,
const struct retro_keybind *default_value,
rarch_setting_group_info_t *group_info,
rarch_setting_group_info_t *subgroup_info,
const char *parent_group)
{
(*list)[list_info->index++] = setting_bind_setting(name, SHORT, target,
player, player_offset, default_value,
group_info->name, subgroup_info->name, parent_group,
true);
/* Request name and short description to be freed later */
SETTINGS_DATA_LIST_CURRENT_ADD_FREE_FLAGS(list, list_info, SD_FREE_FLAG_NAME | SD_FREE_FLAG_SHORT);
}
static void config_action_alt(
rarch_setting_t **list,
rarch_setting_info_t *list_info,
const char *name, const char *SHORT,
rarch_setting_group_info_t *group_info,
rarch_setting_group_info_t *subgroup_info,
const char *parent_group)
{
(*list)[list_info->index++] = setting_action_setting(name, SHORT,
group_info->name, subgroup_info->name, parent_group,
true);
}
static void config_action(
rarch_setting_t **list,
rarch_setting_info_t *list_info,
enum msg_hash_enums name_enum_idx,
enum msg_hash_enums SHORT_enum_idx,
rarch_setting_group_info_t *group_info,
rarch_setting_group_info_t *subgroup_info,
const char *parent_group)
{
(*list)[list_info->index++] = setting_action_setting(
msg_hash_to_str(name_enum_idx),
msg_hash_to_str(SHORT_enum_idx),
group_info->name,
subgroup_info->name, parent_group,
false);
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_IDX_PTR(list, list_info, name_enum_idx);
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_VALUE_IDX(list, list_info, SHORT_enum_idx);
}
static void START_GROUP(rarch_setting_t **list, rarch_setting_info_t *list_info,
rarch_setting_group_info_t *group_info,
const char *name, const char *parent_group)
{
group_info->name = name;
if (SETTINGS_LIST_APPEND(list, list_info))
(*list)[list_info->index++] = setting_group_setting (ST_GROUP, name, parent_group);
}
static void end_group(rarch_setting_t **list,
rarch_setting_info_t *list_info,
const char *parent_group)
{
(*list)[list_info->index++] = setting_group_setting (ST_END_GROUP, 0, parent_group);
}
static bool start_sub_group(rarch_setting_t **list,
rarch_setting_info_t *list_info, const char *name,
rarch_setting_group_info_t *group_info,
rarch_setting_group_info_t *subgroup_info,
const char *parent_group)
{
subgroup_info->name = name;
if (!SETTINGS_LIST_APPEND(list, list_info))
return false;
(*list)[list_info->index++] = setting_subgroup_setting (ST_SUB_GROUP,
name, group_info->name, parent_group, false);
return true;
}
static void end_sub_group(
rarch_setting_t **list,
rarch_setting_info_t *list_info,
const char *parent_group)
{
(*list)[list_info->index++] = setting_group_setting (ST_END_SUB_GROUP, 0, parent_group);
}
/* MENU SETTINGS */
static int setting_action_ok_bind_all(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
if (!menu_input_key_bind_set_mode(MENU_INPUT_BINDS_CTL_BIND_ALL, setting))
return -1;
return 0;
}
#ifdef HAVE_CONFIGFILE
static int setting_action_ok_bind_all_save_autoconfig(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
unsigned index_offset = 0;
unsigned map = 0;
const char *name = NULL;
settings_t *settings = config_get_ptr();
if (!setting)
return -1;
index_offset = setting->index_offset;
map = settings->uints.input_joypad_index[index_offset];
name = input_config_get_device_name(map);
if (!string_is_empty(name) &&
config_save_autoconf_profile(name, index_offset))
{
char buf[PATH_MAX_LENGTH];
char msg[PATH_MAX_LENGTH];
config_get_autoconf_profile_filename(name, index_offset, buf, sizeof(buf));
snprintf(msg, sizeof(msg),msg_hash_to_str(MSG_AUTOCONFIG_FILE_SAVED_SUCCESSFULLY_NAMED),buf);
runloop_msg_queue_push(
msg, 1, 180, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
else
runloop_msg_queue_push(
msg_hash_to_str(MSG_AUTOCONFIG_FILE_ERROR_SAVING), 1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
return 0;
}
#endif
static int setting_action_ok_bind_defaults(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
unsigned i;
struct menu_state *menu_st = menu_state_get_ptr();
struct menu_bind_state *binds = &menu_st->input_binds;
struct retro_keybind *target = NULL;
const struct retro_keybind *def_binds = NULL;
if (!setting)
return -1;
target = &input_config_binds[setting->index_offset][0];
def_binds = (setting->index_offset)
? retro_keybinds_rest
: retro_keybinds_1;
binds->begin = MENU_SETTINGS_BIND_BEGIN;
binds->last = MENU_SETTINGS_BIND_LAST;
for ( i = MENU_SETTINGS_BIND_BEGIN;
i <= MENU_SETTINGS_BIND_LAST; i++, target++)
{
target->key = def_binds[i - MENU_SETTINGS_BIND_BEGIN].key;
target->joykey = NO_BTN;
target->joyaxis = AXIS_NONE;
target->mbutton = NO_BTN;
}
return 0;
}
static int setting_action_ok_video_refresh_rate_auto(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
double video_refresh_rate = 0.0;
double deviation = 0.0;
unsigned sample_points = 0;
if (video_monitor_fps_statistics(&video_refresh_rate,
&deviation, &sample_points))
{
float video_refresh_rate_float = (float)video_refresh_rate;
driver_ctl(RARCH_DRIVER_CTL_SET_REFRESH_RATE, &video_refresh_rate_float);
/* Incase refresh rate update forced non-block video. */
command_event(CMD_EVENT_VIDEO_SET_BLOCKING_STATE, NULL);
}
/* Send NULL instead of setting to prevent duplicate notifications */
if (setting_generic_action_ok_default(NULL, idx, wraparound) != 0)
return -1;
return 0;
}
static int setting_action_ok_video_refresh_rate_polled(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
float refresh_rate = 0.0;
if ((refresh_rate = video_driver_get_refresh_rate()) == 0.0)
return -1;
driver_ctl(RARCH_DRIVER_CTL_SET_REFRESH_RATE, &refresh_rate);
/* Incase refresh rate update forced non-block video. */
command_event(CMD_EVENT_VIDEO_SET_BLOCKING_STATE, NULL);
/* Send NULL instead of setting to prevent duplicate notifications */
if (setting_generic_action_ok_default(NULL, idx, wraparound) != 0)
return -1;
return 0;
}
static int setting_action_ok_uint_special(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
char enum_idx[16];
if (!setting)
return -1;
snprintf(enum_idx, sizeof(enum_idx), "%d", setting->enum_idx);
generic_action_ok_displaylist_push(
enum_idx, /* we will pass the enumeration index of the string as a path */
NULL, NULL, 0, idx, 0,
ACTION_OK_DL_DROPDOWN_BOX_LIST_SPECIAL);
return 0;
}
static int setting_action_ok_uint(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
char enum_idx[16];
if (!setting)
return -1;
snprintf(enum_idx, sizeof(enum_idx), "%d", setting->enum_idx);
generic_action_ok_displaylist_push(
enum_idx, /* we will pass the enumeration index of the string as a path */
NULL, NULL, 0, idx, 0,
ACTION_OK_DL_DROPDOWN_BOX_LIST);
return 1;
}
#if defined(HAVE_NETWORKING)
static void setting_action_ok_color_rgb_cb(void *userdata, const char *line)
{
if (!string_is_empty(line))
{
struct menu_state *menu_st = menu_state_get_ptr();
const char *label = menu_st->input_dialog_kb_label_setting;
rarch_setting_t *setting = menu_setting_find(label);
if (setting)
{
unsigned rgb;
char *rgb_end = NULL;
if (*line == '#')
line++;
rgb = (unsigned)strtoul(line, &rgb_end, 16);
if (!(*rgb_end) && (rgb_end - line) == STRLEN_CONST("RRGGBB"))
*setting->value.target.unsigned_integer = rgb;
}
}
menu_input_dialog_end();
}
static int setting_action_ok_color_rgb(rarch_setting_t *setting, size_t idx,
bool wraparound)
{
menu_input_ctx_line_t line;
if (!setting)
return -1;
line.label = setting->short_description;
line.label_setting = setting->name;
line.type = 0;
line.idx = 0;
line.cb = setting_action_ok_color_rgb_cb;
if (!menu_input_dialog_start(&line))
return -1;
return 0;
}
#endif
static int setting_action_ok_libretro_device_type(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
char enum_idx[16];
if (!setting)
return -1;
snprintf(enum_idx, sizeof(enum_idx), "%d", setting->enum_idx);
generic_action_ok_displaylist_push(
enum_idx, /* we will pass the enumeration index of the string as a path */
NULL, NULL, 0, idx, 0,
ACTION_OK_DL_DROPDOWN_BOX_LIST_INPUT_DEVICE_TYPE);
return 0;
}
#ifdef ANDROID
static int setting_action_ok_select_physical_keyboard(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
char enum_idx[16];
if (!setting)
return -1;
snprintf(enum_idx, sizeof(enum_idx), "%d", setting->enum_idx);
generic_action_ok_displaylist_push(
enum_idx, /* we will pass the enumeration index of the string as a path */
NULL, NULL, 0, idx, 0,
ACTION_OK_DL_DROPDOWN_BOX_LIST_INPUT_SELECT_PHYSICAL_KEYBOARD);
return 0;
}
#endif
#if !defined(RARCH_CONSOLE)
static int setting_string_action_ok_audio_device(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
char enum_idx[16];
if (!setting)
return -1;
snprintf(enum_idx, sizeof(enum_idx), "%d", setting->enum_idx);
generic_action_ok_displaylist_push(
enum_idx, /* we will pass the enumeration index of the string as a path */
NULL, NULL, 0, idx, 0,
ACTION_OK_DL_DROPDOWN_BOX_LIST_AUDIO_DEVICE);
return 0;
}
static int setting_string_action_start_audio_device(rarch_setting_t *setting)
{
if (!setting)
return -1;
strlcpy(setting->value.target.string, "", setting->size);
command_event(CMD_EVENT_AUDIO_REINIT, NULL);
return 0;
}
#ifdef HAVE_MICROPHONE
static int setting_string_action_start_microphone_device(rarch_setting_t *setting)
{
if (!setting)
return -1;
strlcpy(setting->value.target.string, "", setting->size);
command_event(CMD_EVENT_MICROPHONE_REINIT, NULL);
return 0;
}
static int setting_string_action_ok_microphone_device(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
char enum_idx[16];
if (!setting)
return -1;
snprintf(enum_idx, sizeof(enum_idx), "%d", setting->enum_idx);
generic_action_ok_displaylist_push(
enum_idx, /* we will pass the enumeration index of the string as a path */
NULL, NULL, 0, idx, 0,
ACTION_OK_DL_DROPDOWN_BOX_LIST_MICROPHONE_DEVICE);
return 0;
}
#endif
#endif
static void setting_get_string_representation_streaming_mode(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case STREAMING_MODE_TWITCH:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_VIDEO_STREAMING_MODE_TWITCH), len);
break;
case STREAMING_MODE_YOUTUBE:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_VIDEO_STREAMING_MODE_YOUTUBE), len);
break;
case STREAMING_MODE_FACEBOOK:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_VIDEO_STREAMING_MODE_FACEBOOK), len);
break;
case STREAMING_MODE_LOCAL:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_VIDEO_STREAMING_MODE_LOCAL), len);
break;
case STREAMING_MODE_CUSTOM:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_VIDEO_STREAMING_MODE_CUSTOM), len);
break;
}
}
static void setting_get_string_representation_video_stream_quality(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case RECORD_CONFIG_TYPE_STREAMING_CUSTOM:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_VIDEO_RECORD_CONFIG_TYPE_STREAMING_CUSTOM), len);
break;
case RECORD_CONFIG_TYPE_STREAMING_LOW_QUALITY:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_VIDEO_RECORD_CONFIG_TYPE_STREAMING_LOW_QUALITY), len);
break;
case RECORD_CONFIG_TYPE_STREAMING_MED_QUALITY:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_VIDEO_RECORD_CONFIG_TYPE_STREAMING_MED_QUALITY), len);
break;
case RECORD_CONFIG_TYPE_STREAMING_HIGH_QUALITY:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_VIDEO_RECORD_CONFIG_TYPE_STREAMING_HIGH_QUALITY), len);
break;
}
}
static void setting_get_string_representation_video_record_quality(rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case RECORD_CONFIG_TYPE_RECORDING_CUSTOM:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_VIDEO_RECORD_CONFIG_TYPE_RECORDING_CUSTOM), len);
break;
case RECORD_CONFIG_TYPE_RECORDING_LOW_QUALITY:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_VIDEO_RECORD_CONFIG_TYPE_RECORDING_LOW_QUALITY), len);
break;
case RECORD_CONFIG_TYPE_RECORDING_MED_QUALITY:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_VIDEO_RECORD_CONFIG_TYPE_RECORDING_MED_QUALITY), len);
break;
case RECORD_CONFIG_TYPE_RECORDING_HIGH_QUALITY:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_VIDEO_RECORD_CONFIG_TYPE_RECORDING_HIGH_QUALITY), len);
break;
case RECORD_CONFIG_TYPE_RECORDING_LOSSLESS_QUALITY:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_VIDEO_RECORD_CONFIG_TYPE_RECORDING_LOSSLESS_QUALITY), len);
break;
case RECORD_CONFIG_TYPE_RECORDING_WEBM_FAST:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_VIDEO_RECORD_CONFIG_TYPE_RECORDING_WEBM_FAST), len);
break;
case RECORD_CONFIG_TYPE_RECORDING_WEBM_HIGH_QUALITY:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_VIDEO_RECORD_CONFIG_TYPE_RECORDING_WEBM_HIGH_QUALITY), len);
break;
case RECORD_CONFIG_TYPE_RECORDING_GIF:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_VIDEO_RECORD_CONFIG_TYPE_RECORDING_GIF), len);
break;
case RECORD_CONFIG_TYPE_RECORDING_APNG:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_VIDEO_RECORD_CONFIG_TYPE_RECORDING_APNG), len);
break;
}
}
static void setting_get_string_representation_video_filter(rarch_setting_t *setting,
char *s, size_t len)
{
if (setting)
fill_pathname(s, path_basename(setting->value.target.string),
"", len);
}
static void setting_get_string_representation_video_font_path(rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
if (string_is_empty(setting->value.target.string))
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_DONT_CARE), len);
else
fill_pathname(s, path_basename(setting->value.target.string),
"", len);
}
static void setting_get_string_representation_state_slot(rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
snprintf(s, len, "%d", *setting->value.target.integer);
if (*setting->value.target.integer == -1)
strlcpy(s, "Auto", len);
}
static void setting_get_string_representation_percentage(rarch_setting_t *setting,
char *s, size_t len)
{
if (setting)
snprintf(s, len, "%d%%", *setting->value.target.integer);
}
static void setting_get_string_representation_float_video_msg_color(rarch_setting_t *setting,
char *s, size_t len)
{
if (setting)
snprintf(s, len, "%d", (int)(*setting->value.target.fraction * 255.0f));
}
static void setting_get_string_representation_max_users(rarch_setting_t *setting,
char *s, size_t len)
{
if (setting)
snprintf(s, len, "%d", *setting->value.target.unsigned_integer);
}
#if defined(HAVE_CHEEVOS) || defined(HAVE_CLOUDSYNC)
static void setting_get_string_representation_password(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
if (!string_is_empty(setting->value.target.string))
{
s[0] = s[1] = s[2] = s[3] = s[4] = s[5] = s[6] = s[7] = '*';
s[8] = '\0';
}
else
{
settings_t *settings = config_get_ptr();
if (settings->arrays.cheevos_token[0])
{
s[0] = s[1] = s[2] = s[3] = s[4] = s[5] = s[6] = s[7] = '*';
s[8] = '\0';
}
else
*setting->value.target.string = '\0';
}
}
#endif
#if TARGET_OS_IPHONE
static void setting_get_string_representation_uint_keyboard_gamepad_mapping_type(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case 0:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NONE), len);
break;
case 1:
strlcpy(s, "iPega PG-9017", len);
break;
case 2:
strlcpy(s, "8-bitty", len);
break;
case 3:
strlcpy(s, "SNES30 8bitdo", len);
break;
}
}
#endif
#ifdef HAVE_TRANSLATE
static void setting_get_string_representation_uint_ai_service_mode(
rarch_setting_t *setting,
char *s, size_t len)
{
enum msg_hash_enums enum_idx = MSG_UNKNOWN;
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case 0:
enum_idx = MENU_ENUM_LABEL_VALUE_AI_SERVICE_IMAGE_MODE;
break;
case 1:
enum_idx = MENU_ENUM_LABEL_VALUE_AI_SERVICE_SPEECH_MODE;
break;
case 2:
enum_idx = MENU_ENUM_LABEL_VALUE_AI_SERVICE_NARRATOR_MODE;
break;
default:
break;
}
if (enum_idx != 0)
strlcpy(s, msg_hash_to_str(enum_idx), len);
}
static void setting_get_string_representation_uint_ai_service_lang(
rarch_setting_t *setting,
char *s, size_t len)
{
enum msg_hash_enums enum_idx = MSG_UNKNOWN;
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case TRANSLATION_LANG_EN:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_ENGLISH;
break;
case TRANSLATION_LANG_ES:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_SPANISH;
break;
case TRANSLATION_LANG_FR:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_FRENCH;
break;
case TRANSLATION_LANG_IT:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_ITALIAN;
break;
case TRANSLATION_LANG_DE:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_GERMAN;
break;
case TRANSLATION_LANG_JP:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_JAPANESE;
break;
case TRANSLATION_LANG_NL:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_DUTCH;
break;
case TRANSLATION_LANG_CS:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_CZECH;
break;
case TRANSLATION_LANG_DA:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_DANISH;
break;
/* TODO/FIXME */
case TRANSLATION_LANG_SV:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_SWEDISH;
break;
case TRANSLATION_LANG_HR:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_CROATIAN;
break;
case TRANSLATION_LANG_CA:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_CATALAN;
break;
case TRANSLATION_LANG_AST:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_ASTURIAN;
break;
case TRANSLATION_LANG_BG:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_BULGARIAN;
break;
case TRANSLATION_LANG_BN:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_BENGALI;
break;
case TRANSLATION_LANG_EU:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_BASQUE;
break;
case TRANSLATION_LANG_AZ:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_AZERBAIJANI;
break;
case TRANSLATION_LANG_SQ:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_ALBANIAN;
break;
case TRANSLATION_LANG_AF:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_AFRIKAANS;
break;
case TRANSLATION_LANG_ET:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_ESTONIAN;
break;
case TRANSLATION_LANG_TL:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_FILIPINO;
break;
case TRANSLATION_LANG_FI:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_FINNISH;
break;
case TRANSLATION_LANG_GL:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_GALICIAN;
break;
case TRANSLATION_LANG_KA:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_GEORGIAN;
break;
case TRANSLATION_LANG_GU:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_GUJARATI;
break;
case TRANSLATION_LANG_HT:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_HAITIAN_CREOLE;
break;
case TRANSLATION_LANG_HE:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_HEBREW;
break;
case TRANSLATION_LANG_HI:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_HINDI;
break;
case TRANSLATION_LANG_HU:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_HUNGARIAN;
break;
case TRANSLATION_LANG_IS:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_ICELANDIC;
break;
case TRANSLATION_LANG_ID:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_INDONESIAN;
break;
case TRANSLATION_LANG_GA:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_IRISH;
break;
case TRANSLATION_LANG_KN:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_KANNADA;
break;
case TRANSLATION_LANG_LA:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_LATIN;
break;
case TRANSLATION_LANG_LV:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_LATVIAN;
break;
case TRANSLATION_LANG_LT:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_LITHUANIAN;
break;
case TRANSLATION_LANG_MK:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_MACEDONIAN;
break;
case TRANSLATION_LANG_MS:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_MALAY;
break;
case TRANSLATION_LANG_MT:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_MALTESE;
break;
case TRANSLATION_LANG_NO:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_NORWEGIAN;
break;
case TRANSLATION_LANG_FA:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_PERSIAN;
break;
case TRANSLATION_LANG_RO:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_ROMANIAN;
break;
case TRANSLATION_LANG_SR:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_SERBIAN;
break;
case TRANSLATION_LANG_SK:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_SLOVAK;
break;
case TRANSLATION_LANG_SL:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_SLOVENIAN;
break;
case TRANSLATION_LANG_SW:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_SWAHILI;
break;
case TRANSLATION_LANG_TA:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_TAMIL;
break;
case TRANSLATION_LANG_TE:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_TELUGU;
break;
case TRANSLATION_LANG_TH:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_THAI;
break;
case TRANSLATION_LANG_UK:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_UKRAINIAN;
break;
case TRANSLATION_LANG_BE:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_BELARUSIAN;
break;
case TRANSLATION_LANG_UR:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_URDU;
break;
case TRANSLATION_LANG_CY:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_WELSH;
break;
case TRANSLATION_LANG_YI:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_YIDDISH;
break;
case TRANSLATION_LANG_RU:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_RUSSIAN;
break;
case TRANSLATION_LANG_PT:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_PORTUGUESE_PORTUGAL;
break;
case TRANSLATION_LANG_TR:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_TURKISH;
break;
case TRANSLATION_LANG_PL:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_POLISH;
break;
case TRANSLATION_LANG_VI:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_VIETNAMESE;
break;
case TRANSLATION_LANG_EL:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_GREEK;
break;
case TRANSLATION_LANG_KO:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_KOREAN;
break;
case TRANSLATION_LANG_EO:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_ESPERANTO;
break;
case TRANSLATION_LANG_AR:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_ARABIC;
break;
case TRANSLATION_LANG_ZH_CN:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_CHINESE_SIMPLIFIED;
break;
case TRANSLATION_LANG_ZH_TW:
enum_idx = MENU_ENUM_LABEL_VALUE_LANG_CHINESE_TRADITIONAL;
break;
case TRANSLATION_LANG_DONT_CARE:
enum_idx = MENU_ENUM_LABEL_VALUE_DONT_CARE;
break;
default:
break;
}
if (enum_idx != 0)
strlcpy(s, msg_hash_to_str(enum_idx), len);
else
snprintf(s, len, "%d", *setting->value.target.unsigned_integer);
}
#endif
static void setting_get_string_representation_uint_menu_thumbnails(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case 0:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_OFF), len);
break;
case 1:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_THUMBNAIL_MODE_SCREENSHOTS), len);
break;
case 2:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_THUMBNAIL_MODE_TITLE_SCREENS), len);
break;
case 3:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_THUMBNAIL_MODE_BOXARTS), len);
break;
}
}
static void setting_get_string_representation_uint_menu_left_thumbnails(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case 0:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_OFF), len);
break;
case 1:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_THUMBNAIL_MODE_SCREENSHOTS), len);
break;
case 2:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_THUMBNAIL_MODE_TITLE_SCREENS), len);
break;
case 3:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_THUMBNAIL_MODE_BOXARTS), len);
break;
}
}
static void setting_set_string_representation_timedate_date_seperator(char *s)
{
settings_t *settings = config_get_ptr();
unsigned menu_timedate_date_separator = settings ?
settings->uints.menu_timedate_date_separator :
MENU_TIMEDATE_DATE_SEPARATOR_HYPHEN;
switch (menu_timedate_date_separator)
{
case MENU_TIMEDATE_DATE_SEPARATOR_SLASH:
string_replace_all_chars(s, '-', '/');
break;
case MENU_TIMEDATE_DATE_SEPARATOR_PERIOD:
string_replace_all_chars(s, '-', '.');
break;
case MENU_TIMEDATE_DATE_SEPARATOR_HYPHEN:
default:
break;
}
}
static void setting_get_string_representation_uint_menu_timedate_style(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case MENU_TIMEDATE_STYLE_YMD_HMS:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_YMD_HMS), len);
break;
case MENU_TIMEDATE_STYLE_YMD_HM:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_YMD_HM), len);
break;
case MENU_TIMEDATE_STYLE_YMD:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_YMD), len);
break;
case MENU_TIMEDATE_STYLE_YM:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_YM), len);
break;
case MENU_TIMEDATE_STYLE_MDYYYY_HMS:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_MDYYYY_HMS), len);
break;
case MENU_TIMEDATE_STYLE_MDYYYY_HM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_MDYYYY_HM), len);
break;
case MENU_TIMEDATE_STYLE_MD_HM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_MD_HM), len);
break;
case MENU_TIMEDATE_STYLE_MDYYYY:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_MDYYYY), len);
break;
case MENU_TIMEDATE_STYLE_MD:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_MD), len);
break;
case MENU_TIMEDATE_STYLE_DDMMYYYY_HMS:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_DDMMYYYY_HMS), len);
break;
case MENU_TIMEDATE_STYLE_DDMMYYYY_HM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_DDMMYYYY_HM), len);
break;
case MENU_TIMEDATE_STYLE_DDMM_HM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_DDMM_HM), len);
break;
case MENU_TIMEDATE_STYLE_DDMMYYYY:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_DDMMYYYY), len);
break;
case MENU_TIMEDATE_STYLE_DDMM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_DDMM), len);
break;
case MENU_TIMEDATE_STYLE_HMS:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_HMS), len);
break;
case MENU_TIMEDATE_STYLE_HM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_HM), len);
break;
case MENU_TIMEDATE_STYLE_YMD_HMS_AMPM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_YMD_HMS_AMPM), len);
break;
case MENU_TIMEDATE_STYLE_YMD_HM_AMPM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_YMD_HM_AMPM), len);
break;
case MENU_TIMEDATE_STYLE_MDYYYY_HMS_AMPM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_MDYYYY_HMS_AMPM), len);
break;
case MENU_TIMEDATE_STYLE_MDYYYY_HM_AMPM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_MDYYYY_HM_AMPM), len);
break;
case MENU_TIMEDATE_STYLE_MD_HM_AMPM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_MD_HM_AMPM), len);
break;
case MENU_TIMEDATE_STYLE_DDMMYYYY_HMS_AMPM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_DDMMYYYY_HMS_AMPM), len);
break;
case MENU_TIMEDATE_STYLE_DDMMYYYY_HM_AMPM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_DDMMYYYY_HM_AMPM), len);
break;
case MENU_TIMEDATE_STYLE_DDMM_HM_AMPM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_DDMM_HM_AMPM), len);
break;
case MENU_TIMEDATE_STYLE_HMS_AMPM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_HMS_AMPM), len);
break;
case MENU_TIMEDATE_STYLE_HM_AMPM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_HM_AMPM), len);
break;
}
/* Change date separator, if required */
setting_set_string_representation_timedate_date_seperator(s);
}
static void setting_get_string_representation_uint_menu_timedate_date_separator(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case MENU_TIMEDATE_DATE_SEPARATOR_HYPHEN:
strlcpy(s, "'-'", len);
break;
case MENU_TIMEDATE_DATE_SEPARATOR_SLASH:
strlcpy(s, "'/'", len);
break;
case MENU_TIMEDATE_DATE_SEPARATOR_PERIOD:
strlcpy(s, "'.'", len);
break;
}
}
static void setting_get_string_representation_uint_menu_add_content_entry_display_type(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case MENU_ADD_CONTENT_ENTRY_DISPLAY_HIDDEN:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_OFF),
len);
break;
case MENU_ADD_CONTENT_ENTRY_DISPLAY_MAIN_TAB:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MENU_ADD_CONTENT_ENTRY_DISPLAY_MAIN_TAB),
len);
break;
case MENU_ADD_CONTENT_ENTRY_DISPLAY_PLAYLISTS_TAB:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MENU_ADD_CONTENT_ENTRY_DISPLAY_PLAYLISTS_TAB),
len);
break;
}
}
static void setting_get_string_representation_uint_menu_contentless_cores_display_type(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case MENU_CONTENTLESS_CORES_DISPLAY_NONE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_OFF),
len);
break;
case MENU_CONTENTLESS_CORES_DISPLAY_ALL:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_SHOW_CONTENTLESS_CORES_ALL),
len);
break;
case MENU_CONTENTLESS_CORES_DISPLAY_SINGLE_PURPOSE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_SHOW_CONTENTLESS_CORES_SINGLE_PURPOSE),
len);
break;
case MENU_CONTENTLESS_CORES_DISPLAY_CUSTOM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_SHOW_CONTENTLESS_CORES_CUSTOM),
len);
break;
}
}
static void setting_get_string_representation_uint_rgui_menu_color_theme(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case RGUI_THEME_CUSTOM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_CUSTOM),
len);
break;
case RGUI_THEME_CLASSIC_RED:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_CLASSIC_RED),
len);
break;
case RGUI_THEME_CLASSIC_ORANGE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_CLASSIC_ORANGE),
len);
break;
case RGUI_THEME_CLASSIC_YELLOW:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_CLASSIC_YELLOW),
len);
break;
case RGUI_THEME_CLASSIC_GREEN:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_CLASSIC_GREEN),
len);
break;
case RGUI_THEME_CLASSIC_BLUE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_CLASSIC_BLUE),
len);
break;
case RGUI_THEME_CLASSIC_VIOLET:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_CLASSIC_VIOLET),
len);
break;
case RGUI_THEME_CLASSIC_GREY:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_CLASSIC_GREY),
len);
break;
case RGUI_THEME_LEGACY_RED:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_LEGACY_RED),
len);
break;
case RGUI_THEME_DARK_PURPLE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_DARK_PURPLE),
len);
break;
case RGUI_THEME_MIDNIGHT_BLUE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_MIDNIGHT_BLUE),
len);
break;
case RGUI_THEME_GOLDEN:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_GOLDEN),
len);
break;
case RGUI_THEME_ELECTRIC_BLUE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_ELECTRIC_BLUE),
len);
break;
case RGUI_THEME_APPLE_GREEN:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_APPLE_GREEN),
len);
break;
case RGUI_THEME_VOLCANIC_RED:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_VOLCANIC_RED),
len);
break;
case RGUI_THEME_LAGOON:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_LAGOON),
len);
break;
case RGUI_THEME_BROGRAMMER:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_BROGRAMMER),
len);
break;
case RGUI_THEME_DRACULA:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_DRACULA),
len);
break;
case RGUI_THEME_FAIRYFLOSS:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_FAIRYFLOSS),
len);
break;
case RGUI_THEME_FLATUI:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_FLATUI),
len);
break;
case RGUI_THEME_GRUVBOX_DARK:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_GRUVBOX_DARK),
len);
break;
case RGUI_THEME_GRUVBOX_LIGHT:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_GRUVBOX_LIGHT),
len);
break;
case RGUI_THEME_HACKING_THE_KERNEL:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_HACKING_THE_KERNEL),
len);
break;
case RGUI_THEME_NORD:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_NORD),
len);
break;
case RGUI_THEME_NOVA:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_NOVA),
len);
break;
case RGUI_THEME_ONE_DARK:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_ONE_DARK),
len);
break;
case RGUI_THEME_PALENIGHT:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_PALENIGHT),
len);
break;
case RGUI_THEME_SOLARIZED_DARK:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_SOLARIZED_DARK),
len);
break;
case RGUI_THEME_SOLARIZED_LIGHT:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_SOLARIZED_LIGHT),
len);
break;
case RGUI_THEME_TANGO_DARK:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_TANGO_DARK),
len);
break;
case RGUI_THEME_TANGO_LIGHT:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_TANGO_LIGHT),
len);
break;
case RGUI_THEME_ZENBURN:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_ZENBURN),
len);
break;
case RGUI_THEME_ANTI_ZENBURN:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_ANTI_ZENBURN),
len);
break;
case RGUI_THEME_FLUX:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_FLUX),
len);
break;
case RGUI_THEME_DYNAMIC:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_DYNAMIC),
len);
break;
case RGUI_THEME_GRAY_DARK:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_GRAY_DARK),
len);
break;
case RGUI_THEME_GRAY_LIGHT:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME_GRAY_LIGHT),
len);
break;
}
}
static void setting_get_string_representation_uint_rgui_thumbnail_scaler(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case RGUI_THUMB_SCALE_POINT:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_THUMB_SCALE_POINT),
len);
break;
case RGUI_THUMB_SCALE_BILINEAR:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_THUMB_SCALE_BILINEAR),
len);
break;
case RGUI_THUMB_SCALE_SINC:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_THUMB_SCALE_SINC),
len);
break;
}
}
static void setting_get_string_representation_uint_rgui_internal_upscale_level(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case RGUI_UPSCALE_NONE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_UPSCALE_NONE),
len);
break;
case RGUI_UPSCALE_AUTO:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_UPSCALE_AUTO),
len);
break;
case RGUI_UPSCALE_X2:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_UPSCALE_X2),
len);
break;
case RGUI_UPSCALE_X3:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_UPSCALE_X3),
len);
break;
case RGUI_UPSCALE_X4:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_UPSCALE_X4),
len);
break;
case RGUI_UPSCALE_X5:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_UPSCALE_X5),
len);
break;
case RGUI_UPSCALE_X6:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_UPSCALE_X6),
len);
break;
case RGUI_UPSCALE_X7:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_UPSCALE_X7),
len);
break;
case RGUI_UPSCALE_X8:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_UPSCALE_X8),
len);
break;
case RGUI_UPSCALE_X9:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_UPSCALE_X9),
len);
break;
}
}
#if !defined(DINGUX)
static void setting_get_string_representation_uint_rgui_aspect_ratio(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case RGUI_ASPECT_RATIO_4_3:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_ASPECT_RATIO_4_3),
len);
break;
case RGUI_ASPECT_RATIO_16_9:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_ASPECT_RATIO_16_9),
len);
break;
case RGUI_ASPECT_RATIO_16_9_CENTRE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_ASPECT_RATIO_16_9_CENTRE),
len);
break;
case RGUI_ASPECT_RATIO_16_10:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_ASPECT_RATIO_16_10),
len);
break;
case RGUI_ASPECT_RATIO_16_10_CENTRE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_ASPECT_RATIO_16_10_CENTRE),
len);
break;
case RGUI_ASPECT_RATIO_21_9:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_ASPECT_RATIO_21_9),
len);
break;
case RGUI_ASPECT_RATIO_21_9_CENTRE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_ASPECT_RATIO_21_9_CENTRE),
len);
break;
case RGUI_ASPECT_RATIO_3_2:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_ASPECT_RATIO_3_2),
len);
break;
case RGUI_ASPECT_RATIO_3_2_CENTRE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_ASPECT_RATIO_3_2_CENTRE),
len);
break;
case RGUI_ASPECT_RATIO_5_3:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_ASPECT_RATIO_5_3),
len);
break;
case RGUI_ASPECT_RATIO_5_3_CENTRE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_ASPECT_RATIO_5_3_CENTRE),
len);
break;
case RGUI_ASPECT_RATIO_AUTO:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_ASPECT_RATIO_AUTO),
len);
break;
}
}
static void setting_get_string_representation_uint_rgui_aspect_ratio_lock(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case RGUI_ASPECT_RATIO_LOCK_NONE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_ASPECT_RATIO_LOCK_NONE),
len);
break;
case RGUI_ASPECT_RATIO_LOCK_FIT_SCREEN:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_ASPECT_RATIO_LOCK_FIT_SCREEN),
len);
break;
case RGUI_ASPECT_RATIO_LOCK_INTEGER:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_ASPECT_RATIO_LOCK_INTEGER),
len);
break;
case RGUI_ASPECT_RATIO_LOCK_FILL_SCREEN:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_ASPECT_RATIO_LOCK_FILL_SCREEN),
len);
break;
}
}
#endif
static void setting_get_string_representation_uint_rgui_particle_effect(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case RGUI_PARTICLE_EFFECT_NONE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_PARTICLE_EFFECT_NONE),
len);
break;
case RGUI_PARTICLE_EFFECT_SNOW:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_PARTICLE_EFFECT_SNOW),
len);
break;
case RGUI_PARTICLE_EFFECT_SNOW_ALT:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_PARTICLE_EFFECT_SNOW_ALT),
len);
break;
case RGUI_PARTICLE_EFFECT_RAIN:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_PARTICLE_EFFECT_RAIN),
len);
break;
case RGUI_PARTICLE_EFFECT_VORTEX:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_PARTICLE_EFFECT_VORTEX),
len);
break;
case RGUI_PARTICLE_EFFECT_STARFIELD:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_RGUI_PARTICLE_EFFECT_STARFIELD),
len);
break;
}
}
#ifdef HAVE_XMB
static void setting_get_string_representation_uint_menu_xmb_animation_move_up_down(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case 0:
strlcpy(s, "Easing Out Quad", len);
break;
case 1:
strlcpy(s, "Easing Out Expo", len);
break;
case 2:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NONE), len);
break;
}
}
static void setting_get_string_representation_uint_menu_xmb_animation_opening_main_menu(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case 0:
strlcpy(s, "Easing Out Quad", len);
break;
case 1:
strlcpy(s, "Easing Out Circ", len);
break;
case 2:
strlcpy(s, "Easing Out Expo", len);
break;
case 3:
strlcpy(s, "Easing Out Bounce", len);
break;
}
}
static void setting_get_string_representation_uint_menu_xmb_animation_horizontal_highlight(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case 0:
strlcpy(s, "Easing Out Quad", len);
break;
case 1:
strlcpy(s, "Easing In Sine", len);
break;
case 2:
strlcpy(s, "Easing Out Bounce", len);
break;
}
}
#endif
static void setting_get_string_representation_uint_menu_ticker_type(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case TICKER_TYPE_BOUNCE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MENU_TICKER_TYPE_BOUNCE),
len);
break;
case TICKER_TYPE_LOOP:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MENU_TICKER_TYPE_LOOP),
len);
break;
}
}
#ifdef HAVE_XMB
static void setting_get_string_representation_uint_xmb_icon_theme(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case XMB_ICON_THEME_MONOCHROME:
strlcpy(s,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_MONOCHROME), len);
break;
case XMB_ICON_THEME_FLATUI:
strlcpy(s,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_FLATUI), len);
break;
case XMB_ICON_THEME_RETROACTIVE:
strlcpy(s,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_RETROACTIVE), len);
break;
case XMB_ICON_THEME_RETROSYSTEM:
strlcpy(s,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_RETROSYSTEM), len);
break;
case XMB_ICON_THEME_PIXEL:
strlcpy(s,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_PIXEL), len);
break;
case XMB_ICON_THEME_NEOACTIVE:
strlcpy(s,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_NEOACTIVE), len);
break;
case XMB_ICON_THEME_SYSTEMATIC:
strlcpy(s,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_SYSTEMATIC), len);
break;
case XMB_ICON_THEME_DOTART:
strlcpy(s,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_DOTART), len);
break;
case XMB_ICON_THEME_MONOCHROME_INVERTED:
strlcpy(s,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_MONOCHROME_INVERTED), len);
break;
case XMB_ICON_THEME_CUSTOM:
strlcpy(s,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_CUSTOM), len);
break;
case XMB_ICON_THEME_AUTOMATIC:
strlcpy(s,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_AUTOMATIC), len);
break;
case XMB_ICON_THEME_AUTOMATIC_INVERTED:
strlcpy(s,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_AUTOMATIC_INVERTED), len);
break;
case XMB_ICON_THEME_DAITE:
strlcpy(s,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_DAITE), len);
break;
}
}
static void setting_get_string_representation_uint_xmb_layout(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case 0:
strlcpy(s, "Auto", len);
break;
case 1:
strlcpy(s, "Console", len);
break;
case 2:
strlcpy(s, "Handheld", len);
break;
}
}
static void setting_get_string_representation_uint_xmb_menu_color_theme(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case XMB_THEME_WALLPAPER:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME_PLAIN),
len);
break;
case XMB_THEME_LEGACY_RED:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME_LEGACY_RED),
len);
break;
case XMB_THEME_DARK_PURPLE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME_DARK_PURPLE),
len);
break;
case XMB_THEME_MIDNIGHT_BLUE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME_MIDNIGHT_BLUE),
len);
break;
case XMB_THEME_GOLDEN:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME_GOLDEN),
len);
break;
case XMB_THEME_ELECTRIC_BLUE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME_ELECTRIC_BLUE),
len);
break;
case XMB_THEME_APPLE_GREEN:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME_APPLE_GREEN),
len);
break;
case XMB_THEME_UNDERSEA:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME_UNDERSEA),
len);
break;
case XMB_THEME_VOLCANIC_RED:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME_VOLCANIC_RED),
len);
break;
case XMB_THEME_DARK:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME_DARK),
len);
break;
case XMB_THEME_LIGHT:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME_LIGHT),
len);
break;
case XMB_THEME_MORNING_BLUE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME_MORNING_BLUE),
len);
break;
case XMB_THEME_SUNBEAM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME_SUNBEAM),
len);
break;
case XMB_THEME_LIME:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME_LIME),
len);
break;
case XMB_THEME_MIDGAR:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME_MIDGAR),
len);
break;
case XMB_THEME_PIKACHU_YELLOW:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME_PIKACHU_YELLOW),
len);
break;
case XMB_THEME_GAMECUBE_PURPLE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME_GAMECUBE_PURPLE),
len);
break;
case XMB_THEME_FAMICOM_RED:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME_FAMICOM_RED),
len);
break;
case XMB_THEME_FLAMING_HOT:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME_FLAMING_HOT),
len);
break;
case XMB_THEME_ICE_COLD:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME_ICE_COLD),
len);
break;
}
}
#endif
#ifdef HAVE_MATERIALUI
static void setting_get_string_representation_uint_materialui_menu_color_theme(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case MATERIALUI_THEME_BLUE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_COLOR_THEME_BLUE), len);
break;
case MATERIALUI_THEME_BLUE_GREY:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_COLOR_THEME_BLUE_GREY), len);
break;
case MATERIALUI_THEME_GREEN:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_COLOR_THEME_GREEN), len);
break;
case MATERIALUI_THEME_RED:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_COLOR_THEME_RED), len);
break;
case MATERIALUI_THEME_YELLOW:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_COLOR_THEME_YELLOW), len);
break;
case MATERIALUI_THEME_DARK_BLUE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_COLOR_THEME_DARK_BLUE), len);
break;
case MATERIALUI_THEME_NVIDIA_SHIELD:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_COLOR_THEME_NVIDIA_SHIELD), len);
break;
case MATERIALUI_THEME_MATERIALUI:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_COLOR_THEME_MATERIALUI), len);
break;
case MATERIALUI_THEME_MATERIALUI_DARK:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_COLOR_THEME_MATERIALUI_DARK), len);
break;
case MATERIALUI_THEME_OZONE_DARK:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_COLOR_THEME_OZONE_DARK), len);
break;
case MATERIALUI_THEME_NORD:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_COLOR_THEME_NORD), len);
break;
case MATERIALUI_THEME_GRUVBOX_DARK:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_COLOR_THEME_GRUVBOX_DARK), len);
break;
case MATERIALUI_THEME_SOLARIZED_DARK:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_COLOR_THEME_SOLARIZED_DARK), len);
break;
case MATERIALUI_THEME_CUTIE_BLUE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_COLOR_THEME_CUTIE_BLUE), len);
break;
case MATERIALUI_THEME_CUTIE_CYAN:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_COLOR_THEME_CUTIE_CYAN), len);
break;
case MATERIALUI_THEME_CUTIE_GREEN:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_COLOR_THEME_CUTIE_GREEN), len);
break;
case MATERIALUI_THEME_CUTIE_ORANGE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_COLOR_THEME_CUTIE_ORANGE), len);
break;
case MATERIALUI_THEME_CUTIE_PINK:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_COLOR_THEME_CUTIE_PINK), len);
break;
case MATERIALUI_THEME_CUTIE_PURPLE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_COLOR_THEME_CUTIE_PURPLE), len);
break;
case MATERIALUI_THEME_CUTIE_RED:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_COLOR_THEME_CUTIE_RED), len);
break;
case MATERIALUI_THEME_VIRTUAL_BOY:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_COLOR_THEME_VIRTUAL_BOY), len);
break;
case MATERIALUI_THEME_HACKING_THE_KERNEL:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_COLOR_THEME_HACKING_THE_KERNEL), len);
break;
case MATERIALUI_THEME_GRAY_DARK:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_COLOR_THEME_GRAY_DARK), len);
break;
case MATERIALUI_THEME_GRAY_LIGHT:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_COLOR_THEME_GRAY_LIGHT), len);
break;
default:
break;
}
}
static void setting_get_string_representation_uint_materialui_menu_transition_animation(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case MATERIALUI_TRANSITION_ANIM_AUTO:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_TRANSITION_ANIM_AUTO), len);
break;
case MATERIALUI_TRANSITION_ANIM_FADE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_TRANSITION_ANIM_FADE), len);
break;
case MATERIALUI_TRANSITION_ANIM_SLIDE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_TRANSITION_ANIM_SLIDE), len);
break;
case MATERIALUI_TRANSITION_ANIM_NONE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_TRANSITION_ANIM_NONE), len);
break;
default:
break;
}
}
static void setting_get_string_representation_uint_materialui_menu_thumbnail_view_portrait(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case MATERIALUI_THUMBNAIL_VIEW_PORTRAIT_DISABLED:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_THUMBNAIL_VIEW_PORTRAIT_DISABLED), len);
break;
case MATERIALUI_THUMBNAIL_VIEW_PORTRAIT_LIST_SMALL:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_THUMBNAIL_VIEW_PORTRAIT_LIST_SMALL), len);
break;
case MATERIALUI_THUMBNAIL_VIEW_PORTRAIT_LIST_MEDIUM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_THUMBNAIL_VIEW_PORTRAIT_LIST_MEDIUM), len);
break;
case MATERIALUI_THUMBNAIL_VIEW_PORTRAIT_DUAL_ICON:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_THUMBNAIL_VIEW_PORTRAIT_DUAL_ICON), len);
break;
default:
break;
}
}
static void setting_get_string_representation_uint_materialui_menu_thumbnail_view_landscape(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case MATERIALUI_THUMBNAIL_VIEW_LANDSCAPE_DISABLED:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_THUMBNAIL_VIEW_LANDSCAPE_DISABLED), len);
break;
case MATERIALUI_THUMBNAIL_VIEW_LANDSCAPE_LIST_SMALL:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_THUMBNAIL_VIEW_LANDSCAPE_LIST_SMALL), len);
break;
case MATERIALUI_THUMBNAIL_VIEW_LANDSCAPE_LIST_MEDIUM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_THUMBNAIL_VIEW_LANDSCAPE_LIST_MEDIUM), len);
break;
case MATERIALUI_THUMBNAIL_VIEW_LANDSCAPE_LIST_LARGE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_THUMBNAIL_VIEW_LANDSCAPE_LIST_LARGE), len);
break;
case MATERIALUI_THUMBNAIL_VIEW_LANDSCAPE_DESKTOP:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_THUMBNAIL_VIEW_LANDSCAPE_DESKTOP), len);
break;
default:
break;
}
}
static void setting_get_string_representation_uint_materialui_landscape_layout_optimization(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case MATERIALUI_LANDSCAPE_LAYOUT_OPTIMIZATION_DISABLED:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_LANDSCAPE_LAYOUT_OPTIMIZATION_DISABLED), len);
break;
case MATERIALUI_LANDSCAPE_LAYOUT_OPTIMIZATION_ALWAYS:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_LANDSCAPE_LAYOUT_OPTIMIZATION_ALWAYS), len);
break;
case MATERIALUI_LANDSCAPE_LAYOUT_OPTIMIZATION_EXCLUDE_THUMBNAIL_VIEWS:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MATERIALUI_LANDSCAPE_LAYOUT_OPTIMIZATION_EXCLUDE_THUMBNAIL_VIEWS), len);
break;
default:
break;
}
}
#endif
#ifdef HAVE_OZONE
static void setting_get_string_representation_uint_ozone_menu_color_theme(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case OZONE_COLOR_THEME_BASIC_BLACK:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_OZONE_COLOR_THEME_BASIC_BLACK), len);
break;
case OZONE_COLOR_THEME_NORD:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_OZONE_COLOR_THEME_NORD), len);
break;
case OZONE_COLOR_THEME_GRUVBOX_DARK:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_OZONE_COLOR_THEME_GRUVBOX_DARK), len);
break;
case OZONE_COLOR_THEME_BOYSENBERRY:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_OZONE_COLOR_THEME_BOYSENBERRY), len);
break;
case OZONE_COLOR_THEME_HACKING_THE_KERNEL:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_OZONE_COLOR_THEME_HACKING_THE_KERNEL), len);
break;
case OZONE_COLOR_THEME_TWILIGHT_ZONE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_OZONE_COLOR_THEME_TWILIGHT_ZONE), len);
break;
case OZONE_COLOR_THEME_DRACULA:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_OZONE_COLOR_THEME_DRACULA), len);
break;
case OZONE_COLOR_THEME_SOLARIZED_DARK:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_OZONE_COLOR_THEME_SOLARIZED_DARK), len);
break;
case OZONE_COLOR_THEME_SOLARIZED_LIGHT:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_OZONE_COLOR_THEME_SOLARIZED_LIGHT), len);
break;
case OZONE_COLOR_THEME_GRAY_DARK:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_OZONE_COLOR_THEME_GRAY_DARK), len);
break;
case OZONE_COLOR_THEME_GRAY_LIGHT:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_OZONE_COLOR_THEME_GRAY_LIGHT), len);
break;
case OZONE_COLOR_THEME_PURPLE_RAIN:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_OZONE_COLOR_THEME_PURPLE_RAIN), len);
break;
case OZONE_COLOR_THEME_BASIC_WHITE:
default:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_OZONE_COLOR_THEME_BASIC_WHITE), len);
break;
}
}
#endif
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
#if defined(HAVE_XMB) && defined(HAVE_SHADERPIPELINE)
static void setting_get_string_representation_uint_xmb_shader_pipeline(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case XMB_SHADER_PIPELINE_WALLPAPER:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF), len);
break;
case XMB_SHADER_PIPELINE_SIMPLE_RIBBON:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_SHADER_PIPELINE_RIBBON_SIMPLIFIED), len);
break;
case XMB_SHADER_PIPELINE_RIBBON:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_SHADER_PIPELINE_RIBBON), len);
break;
case XMB_SHADER_PIPELINE_SIMPLE_SNOW:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_SHADER_PIPELINE_SIMPLE_SNOW), len);
break;
case XMB_SHADER_PIPELINE_SNOW:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_SHADER_PIPELINE_SNOW), len);
break;
case XMB_SHADER_PIPELINE_BOKEH:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_SHADER_PIPELINE_BOKEH), len);
break;
case XMB_SHADER_PIPELINE_SNOWFLAKE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_SHADER_PIPELINE_SNOWFLAKE), len);
break;
}
}
#endif
#endif
#ifdef HAVE_SCREENSHOTS
#ifdef HAVE_GFX_WIDGETS
static void setting_get_string_representation_uint_notification_show_screenshot_duration(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case NOTIFICATION_SHOW_SCREENSHOT_DURATION_NORMAL:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NOTIFICATION_SHOW_SCREENSHOT_DURATION_NORMAL), len);
break;
case NOTIFICATION_SHOW_SCREENSHOT_DURATION_FAST:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NOTIFICATION_SHOW_SCREENSHOT_DURATION_FAST), len);
break;
case NOTIFICATION_SHOW_SCREENSHOT_DURATION_VERY_FAST:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NOTIFICATION_SHOW_SCREENSHOT_DURATION_VERY_FAST), len);
break;
case NOTIFICATION_SHOW_SCREENSHOT_DURATION_INSTANT:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NOTIFICATION_SHOW_SCREENSHOT_DURATION_INSTANT), len);
break;
}
}
static void setting_get_string_representation_uint_notification_show_screenshot_flash(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case NOTIFICATION_SHOW_SCREENSHOT_FLASH_NORMAL:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NOTIFICATION_SHOW_SCREENSHOT_FLASH_NORMAL), len);
break;
case NOTIFICATION_SHOW_SCREENSHOT_FLASH_FAST:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NOTIFICATION_SHOW_SCREENSHOT_FLASH_FAST), len);
break;
case NOTIFICATION_SHOW_SCREENSHOT_FLASH_OFF:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF), len);
break;
}
}
#endif
#endif
static void setting_get_string_representation_uint_video_autoswitch_refresh_rate(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case AUTOSWITCH_REFRESH_RATE_EXCLUSIVE_FULLSCREEN:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_AUTOSWITCH_REFRESH_RATE_EXCLUSIVE_FULLSCREEN), len);
break;
case AUTOSWITCH_REFRESH_RATE_WINDOWED_FULLSCREEN:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_AUTOSWITCH_REFRESH_RATE_WINDOWED_FULLSCREEN), len);
break;
case AUTOSWITCH_REFRESH_RATE_ALL_FULLSCREEN:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_AUTOSWITCH_REFRESH_RATE_ALL_FULLSCREEN), len);
break;
case AUTOSWITCH_REFRESH_RATE_OFF:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF), len);
break;
}
}
static void setting_get_string_representation_uint_video_monitor_index(rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
if (*setting->value.target.unsigned_integer)
snprintf(s, len, "%u",
*setting->value.target.unsigned_integer);
else
strlcpy(s, "0 (Auto)", len);
}
static void setting_get_string_representation_uint_custom_viewport_width(rarch_setting_t *setting,
char *s, size_t len)
{
size_t _len;
struct retro_game_geometry *geom = NULL;
video_driver_state_t *video_st = video_state_get_ptr();
struct retro_system_av_info *av_info = &video_st->av_info;
unsigned int rotation = retroarch_get_rotation();
if (!setting || !av_info)
return;
geom = (struct retro_game_geometry*)&av_info->geometry;
_len = snprintf(s, len, "%u",
*setting->value.target.unsigned_integer);
if (!(rotation % 2) && (*setting->value.target.unsigned_integer % geom->base_width == 0))
snprintf(s + _len, len - _len, " (%ux)",
*setting->value.target.unsigned_integer / geom->base_width);
else if ((rotation % 2) && (*setting->value.target.unsigned_integer % geom->base_height == 0))
snprintf(s + _len, len - _len, " (%ux)",
*setting->value.target.unsigned_integer / geom->base_height);
}
static void setting_get_string_representation_uint_custom_viewport_height(rarch_setting_t *setting,
char *s, size_t len)
{
size_t _len;
struct retro_game_geometry *geom = NULL;
video_driver_state_t *video_st = video_state_get_ptr();
struct retro_system_av_info *av_info = &video_st->av_info;
unsigned int rotation = retroarch_get_rotation();
if (!setting || !av_info)
return;
geom = (struct retro_game_geometry*)&av_info->geometry;
_len = snprintf(s, len, "%u",
*setting->value.target.unsigned_integer);
if (!(rotation % 2) && (*setting->value.target.unsigned_integer % geom->base_height == 0))
snprintf(s + _len, len - _len, " (%ux)",
*setting->value.target.unsigned_integer / geom->base_height);
else if ((rotation % 2) && (*setting->value.target.unsigned_integer % geom->base_width == 0))
snprintf(s + _len, len - _len, " (%ux)",
*setting->value.target.unsigned_integer / geom->base_width);
}
#ifdef HAVE_WASAPI
static void setting_get_string_representation_uint_audio_wasapi_sh_buffer_length(rarch_setting_t *setting,
char *s, size_t len)
{
settings_t *settings = config_get_ptr();
if (!setting || !settings)
return;
switch (*setting->value.target.integer)
{
case WASAPI_SH_BUFFER_AUDIO_LATENCY:
snprintf(s, len, "%u (%s)",
*setting->value.target.integer,
"Audio Latency");
break;
case WASAPI_SH_BUFFER_DEVICE_PERIOD:
snprintf(s, len, "%u (%s)",
*setting->value.target.integer,
"Device Period");
break;
case WASAPI_SH_BUFFER_CLIENT_BUFFER:
snprintf(s, len, "%u (%s)",
*setting->value.target.integer,
"Client Buffer");
break;
default:
snprintf(s, len, "%u (%.1f ms)",
*setting->value.target.integer,
(float)*setting->value.target.integer * 1000 / settings->uints.audio_output_sample_rate);
break;
}
}
#ifdef HAVE_MICROPHONE
static void setting_get_string_representation_uint_microphone_wasapi_sh_buffer_length(rarch_setting_t *setting,
char *s, size_t len)
{
settings_t *settings = config_get_ptr();
if (!setting || !settings)
return;
if (*setting->value.target.integer > 0)
snprintf(s, len, "%u (%.1f ms)",
*setting->value.target.integer,
(float)*setting->value.target.integer * 1000 / settings->uints.audio_output_sample_rate);
else
strlcpy(s, "Auto", len);
}
#endif
#endif
#if !defined(RARCH_CONSOLE)
static void setting_get_string_representation_string_audio_device(rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
if (string_is_empty(setting->value.target.string))
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_DONT_CARE), len);
else
strlcpy(s, setting->value.target.string, len);
}
#endif
static void setting_get_string_representation_crt_switch_resolution_super(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
if (*setting->value.target.unsigned_integer == 0)
strlcpy(s, "NATIVE", len);
else if (*setting->value.target.unsigned_integer == 1)
strlcpy(s, "DYNAMIC", len);
else
snprintf(s, len, "%d", *setting->value.target.unsigned_integer);
}
static void setting_get_string_representation_uint_playlist_sublabel_runtime_type(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case PLAYLIST_RUNTIME_PER_CORE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_PLAYLIST_RUNTIME_PER_CORE),
len);
break;
case PLAYLIST_RUNTIME_AGGREGATE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_PLAYLIST_RUNTIME_AGGREGATE),
len);
break;
}
}
static void setting_get_string_representation_uint_playlist_sublabel_last_played_style(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case PLAYLIST_LAST_PLAYED_STYLE_YMD_HMS:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_YMD_HMS),
len);
break;
case PLAYLIST_LAST_PLAYED_STYLE_YMD_HM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_YMD_HM),
len);
break;
case PLAYLIST_LAST_PLAYED_STYLE_YMD:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_YMD),
len);
break;
case PLAYLIST_LAST_PLAYED_STYLE_YM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_YM),
len);
break;
case PLAYLIST_LAST_PLAYED_STYLE_MDYYYY_HMS:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_MDYYYY_HMS),
len);
break;
case PLAYLIST_LAST_PLAYED_STYLE_MDYYYY_HM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_MDYYYY_HM),
len);
break;
case PLAYLIST_LAST_PLAYED_STYLE_MD_HM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_MD_HM),
len);
break;
case PLAYLIST_LAST_PLAYED_STYLE_MDYYYY:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_MDYYYY),
len);
break;
case PLAYLIST_LAST_PLAYED_STYLE_MD:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_MD),
len);
break;
case PLAYLIST_LAST_PLAYED_STYLE_DDMMYYYY_HMS:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_DDMMYYYY_HMS),
len);
break;
case PLAYLIST_LAST_PLAYED_STYLE_DDMMYYYY_HM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_DDMMYYYY_HM),
len);
break;
case PLAYLIST_LAST_PLAYED_STYLE_DDMM_HM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_DDMM_HM),
len);
break;
case PLAYLIST_LAST_PLAYED_STYLE_DDMMYYYY:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_DDMMYYYY),
len);
break;
case PLAYLIST_LAST_PLAYED_STYLE_DDMM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_DDMM),
len);
break;
case PLAYLIST_LAST_PLAYED_STYLE_YMD_HMS_AMPM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_YMD_HMS_AMPM),
len);
break;
case PLAYLIST_LAST_PLAYED_STYLE_YMD_HM_AMPM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_YMD_HM_AMPM),
len);
break;
case PLAYLIST_LAST_PLAYED_STYLE_MDYYYY_HMS_AMPM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_MDYYYY_HMS_AMPM),
len);
break;
case PLAYLIST_LAST_PLAYED_STYLE_MDYYYY_HM_AMPM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_MDYYYY_HM_AMPM),
len);
break;
case PLAYLIST_LAST_PLAYED_STYLE_MD_HM_AMPM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_MD_HM_AMPM),
len);
break;
case PLAYLIST_LAST_PLAYED_STYLE_DDMMYYYY_HMS_AMPM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_DDMMYYYY_HMS_AMPM),
len);
break;
case PLAYLIST_LAST_PLAYED_STYLE_DDMMYYYY_HM_AMPM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_DDMMYYYY_HM_AMPM),
len);
break;
case PLAYLIST_LAST_PLAYED_STYLE_DDMM_HM_AMPM:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_DDMM_HM_AMPM),
len);
break;
case PLAYLIST_LAST_PLAYED_STYLE_AGO:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_TIMEDATE_AGO),
len);
break;
}
/* Change date separator, if required */
setting_set_string_representation_timedate_date_seperator(s);
}
static void setting_get_string_representation_uint_playlist_inline_core_display_type(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case PLAYLIST_INLINE_CORE_DISPLAY_HIST_FAV:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_PLAYLIST_INLINE_CORE_DISPLAY_HIST_FAV),
len);
break;
case PLAYLIST_INLINE_CORE_DISPLAY_ALWAYS:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_PLAYLIST_INLINE_CORE_DISPLAY_ALWAYS),
len);
break;
case PLAYLIST_INLINE_CORE_DISPLAY_NEVER:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_PLAYLIST_INLINE_CORE_DISPLAY_NEVER),
len);
break;
}
}
static void setting_get_string_representation_uint_playlist_entry_remove_enable(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case PLAYLIST_ENTRY_REMOVE_ENABLE_HIST_FAV:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_PLAYLIST_ENTRY_REMOVE_ENABLE_HIST_FAV),
len);
break;
case PLAYLIST_ENTRY_REMOVE_ENABLE_ALL:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_PLAYLIST_ENTRY_REMOVE_ENABLE_ALL),
len);
break;
case PLAYLIST_ENTRY_REMOVE_ENABLE_NONE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_PLAYLIST_ENTRY_REMOVE_ENABLE_NONE),
len);
break;
}
}
#ifdef _3DS
static void setting_get_string_representation_uint_video_3ds_display_mode(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case CTR_VIDEO_MODE_3D:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_CTR_VIDEO_MODE_3D),
len);
break;
case CTR_VIDEO_MODE_2D:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_CTR_VIDEO_MODE_2D),
len);
break;
case CTR_VIDEO_MODE_2D_400X240:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_CTR_VIDEO_MODE_2D_400X240),
len);
break;
case CTR_VIDEO_MODE_2D_800X240:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_CTR_VIDEO_MODE_2D_800X240),
len);
break;
}
}
#endif
#if defined(DINGUX)
static void setting_get_string_representation_uint_video_dingux_ipu_filter_type(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case DINGUX_IPU_FILTER_BICUBIC:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_VIDEO_DINGUX_IPU_FILTER_BICUBIC),
len);
break;
case DINGUX_IPU_FILTER_BILINEAR:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_VIDEO_DINGUX_IPU_FILTER_BILINEAR),
len);
break;
case DINGUX_IPU_FILTER_NEAREST:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_VIDEO_DINGUX_IPU_FILTER_NEAREST),
len);
break;
}
}
#if defined(DINGUX_BETA)
static void setting_get_string_representation_uint_video_dingux_refresh_rate(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case DINGUX_REFRESH_RATE_60HZ:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_VIDEO_DINGUX_REFRESH_RATE_60HZ),
len);
break;
case DINGUX_REFRESH_RATE_50HZ:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_VIDEO_DINGUX_REFRESH_RATE_50HZ),
len);
break;
}
}
#endif
#if defined(RS90) || defined(MIYOO)
static void setting_get_string_representation_uint_video_dingux_rs90_softfilter_type(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case DINGUX_RS90_SOFTFILTER_POINT:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_VIDEO_DINGUX_RS90_SOFTFILTER_POINT),
len);
break;
case DINGUX_RS90_SOFTFILTER_BRESENHAM_HORZ:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_VIDEO_DINGUX_RS90_SOFTFILTER_BRESENHAM_HORZ),
len);
break;
}
}
#endif
#endif
static void setting_get_string_representation_uint_input_auto_game_focus(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case AUTO_GAME_FOCUS_OFF:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_INPUT_AUTO_GAME_FOCUS_OFF),
len);
break;
case AUTO_GAME_FOCUS_ON:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_INPUT_AUTO_GAME_FOCUS_ON),
len);
break;
case AUTO_GAME_FOCUS_DETECT:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_INPUT_AUTO_GAME_FOCUS_DETECT),
len);
break;
}
}
#if defined(HAVE_OVERLAY)
static void setting_get_string_representation_uint_input_overlay_show_inputs(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case OVERLAY_SHOW_INPUT_NONE:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_OFF),
len);
break;
case OVERLAY_SHOW_INPUT_TOUCHED:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_INPUT_OVERLAY_SHOW_INPUTS_TOUCHED),
len);
break;
case OVERLAY_SHOW_INPUT_PHYSICAL:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_INPUT_OVERLAY_SHOW_INPUTS_PHYSICAL),
len);
break;
}
}
static void setting_get_string_representation_uint_input_overlay_show_inputs_port(
rarch_setting_t *setting,
char *s, size_t len)
{
if (setting)
snprintf(s, len, "%u",
*setting->value.target.unsigned_integer + 1);
}
static void setting_get_string_representation_overlay_lightgun_port(
rarch_setting_t *setting, char *s, size_t len)
{
if (setting)
{
if (*setting->value.target.integer < 0)
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_INPUT_OVERLAY_LIGHTGUN_PORT_ANY), len);
else
snprintf(s, len, "%d", *setting->value.target.integer + 1);
}
}
static void setting_get_string_representation_overlay_lightgun_action(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case OVERLAY_LIGHTGUN_ACTION_NONE:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_NONE), len);
break;
case OVERLAY_LIGHTGUN_ACTION_TRIGGER:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_INPUT_LIGHTGUN_TRIGGER), len);
break;
case OVERLAY_LIGHTGUN_ACTION_RELOAD:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_INPUT_LIGHTGUN_RELOAD), len);
break;
case OVERLAY_LIGHTGUN_ACTION_AUX_A:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_INPUT_LIGHTGUN_AUX_A), len);
break;
case OVERLAY_LIGHTGUN_ACTION_AUX_B:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_INPUT_LIGHTGUN_AUX_B), len);
break;
case OVERLAY_LIGHTGUN_ACTION_AUX_C:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_INPUT_LIGHTGUN_AUX_C), len);
break;
case OVERLAY_LIGHTGUN_ACTION_SELECT:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_INPUT_LIGHTGUN_SELECT), len);
break;
case OVERLAY_LIGHTGUN_ACTION_START:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_INPUT_LIGHTGUN_START), len);
break;
case OVERLAY_LIGHTGUN_ACTION_DPAD_UP:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_INPUT_LIGHTGUN_DPAD_UP), len);
break;
case OVERLAY_LIGHTGUN_ACTION_DPAD_DOWN:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_INPUT_LIGHTGUN_DPAD_DOWN), len);
break;
case OVERLAY_LIGHTGUN_ACTION_DPAD_LEFT:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_INPUT_LIGHTGUN_DPAD_LEFT), len);
break;
case OVERLAY_LIGHTGUN_ACTION_DPAD_RIGHT:
strlcpy(s, msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_INPUT_LIGHTGUN_DPAD_RIGHT), len);
break;
}
}
#endif
/* A protected driver is such that the user cannot set to "null" using the UI.
* Can prevent the user from locking him/herself out of the program. */
static bool setting_is_protected_driver(rarch_setting_t *setting)
{
if (setting)
{
switch (setting->enum_idx)
{
case MENU_ENUM_LABEL_INPUT_DRIVER:
case MENU_ENUM_LABEL_JOYPAD_DRIVER:
case MENU_ENUM_LABEL_VIDEO_DRIVER:
case MENU_ENUM_LABEL_MENU_DRIVER:
return true;
default:
break;
}
}
return false;
}
static int setting_action_left_analog_dpad_mode(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
unsigned port = 0;
settings_t *settings = config_get_ptr();
if (!setting)
return -1;
port = setting->index_offset;
configuration_set_uint(settings, settings->uints.input_analog_dpad_mode[port],
(settings->uints.input_analog_dpad_mode
[port] + ANALOG_DPAD_LAST - 1) % ANALOG_DPAD_LAST);
return 0;
}
unsigned libretro_device_get_size(unsigned *devices, size_t devices_size, unsigned port)
{
unsigned types = 0;
const struct retro_controller_info *desc = NULL;
rarch_system_info_t *sys_info = &runloop_state_get_ptr()->system;
devices[types++] = RETRO_DEVICE_NONE;
devices[types++] = RETRO_DEVICE_JOYPAD;
if (sys_info)
{
/* Only push RETRO_DEVICE_ANALOG as default if we use an
* older core which doesn't use SET_CONTROLLER_INFO. */
if (!sys_info->ports.size)
devices[types++] = RETRO_DEVICE_ANALOG;
if (port < sys_info->ports.size)
desc = &sys_info->ports.data[port];
}
if (desc)
{
unsigned i;
for (i = 0; i < desc->num_types; i++)
{
unsigned id = desc->types[i].id;
if (types < devices_size &&
id != RETRO_DEVICE_NONE &&
id != RETRO_DEVICE_JOYPAD)
devices[types++] = id;
}
}
return types;
}
static int setting_action_left_libretro_device_type(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
retro_ctx_controller_info_t pad;
unsigned current_device, current_idx, i, devices[128],
types = 0, port = 0;
struct menu_state *menu_st = menu_state_get_ptr();
if (!setting)
return -1;
port = setting->index_offset;
types = libretro_device_get_size(devices, ARRAY_SIZE(devices), port);
current_device = input_config_get_device(port);
current_idx = 0;
for (i = 0; i < types; i++)
{
if (current_device != devices[i])
continue;
current_idx = i;
break;
}
current_device = devices
[(current_idx + types - 1) % types];
input_config_set_device(port, current_device);
pad.port = port;
pad.device = current_device;
core_set_controller_port_device(&pad);
menu_st->flags |= MENU_ST_FLAG_PREVENT_POPULATE
| MENU_ST_FLAG_ENTRIES_NEED_REFRESH;
return 0;
}
static int setting_action_left_input_remap_port(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
struct menu_state *menu_st = menu_state_get_ptr();
unsigned port = 0;
settings_t *settings = config_get_ptr();
if (!setting)
return -1;
port = setting->index_offset;
if (settings->uints.input_remap_ports[port] > 0)
settings->uints.input_remap_ports[port]--;
else
settings->uints.input_remap_ports[port] = MAX_USERS - 1;
/* Must be called whenever settings->uints.input_remap_ports
* is modified */
input_remapping_update_port_map();
/* Changing mapped port may leave a core port unused;
* reinitialise controllers to ensure that any such
* ports are set to 'RETRO_DEVICE_NONE' */
command_event(CMD_EVENT_CONTROLLER_INIT, NULL);
menu_st->flags |= MENU_ST_FLAG_PREVENT_POPULATE
| MENU_ST_FLAG_ENTRIES_NEED_REFRESH;
return 0;
}
static int setting_uint_action_left_crt_switch_resolution_super(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
if (!setting)
return -1;
switch (*setting->value.target.unsigned_integer)
{
case 0:
*setting->value.target.unsigned_integer = 3840;
break;
case 1: /* for dynamic super resolution switching - best fit */
*setting->value.target.unsigned_integer = 0;
break;
case 1920:
*setting->value.target.unsigned_integer = 1;
break;
case 2560:
*setting->value.target.unsigned_integer = 1920;
break;
case 3840:
*setting->value.target.unsigned_integer = 2560;
break;
}
return 0;
}
static int setting_action_left_input_device_index(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
settings_t *settings = config_get_ptr();
unsigned *p = NULL;
if (!setting || !settings)
return -1;
p = &settings->uints.input_joypad_index[setting->index_offset];
if (*p)
(*p)--;
else
*p = MAX_INPUT_DEVICES - 1;
settings->modified = true;
return 0;
}
static int setting_action_left_input_mouse_index(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
settings_t *settings = config_get_ptr();
unsigned *p = NULL;
if (!setting || !settings)
return -1;
p = &settings->uints.input_mouse_index[setting->index_offset];
if (*p)
(*p)--;
else
*p = MAX_INPUT_DEVICES - 1;
settings->modified = true;
return 0;
}
static int setting_uint_action_left_custom_viewport_width(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
video_viewport_t vp;
video_driver_state_t *video_st = video_state_get_ptr();
struct retro_system_av_info *av_info = &video_st->av_info;
settings_t *settings = config_get_ptr();
video_viewport_t *custom = &settings->video_viewport_custom;
if (!settings || !av_info)
return -1;
video_driver_get_viewport_info(&vp);
if (custom->width <= setting->min)
custom->width = setting->min;
else if (settings->bools.video_scale_integer)
{
struct retro_game_geometry *geom = (struct retro_game_geometry*)
&av_info->geometry;
unsigned int rotation = retroarch_get_rotation();
if (rotation % 2)
{
if (custom->width > geom->base_height)
custom->width -= geom->base_height;
}
else
{
if (custom->width > geom->base_width)
custom->width -= geom->base_width;
}
}
else
custom->width -= 1;
/* aspectratio_lut[ASPECT_RATIO_CUSTOM].value
* is updated in general_write_handler() */
return 0;
}
static int setting_uint_action_left_custom_viewport_height(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
video_viewport_t vp;
video_driver_state_t *video_st = video_state_get_ptr();
struct retro_system_av_info *av_info = &video_st->av_info;
settings_t *settings = config_get_ptr();
video_viewport_t *custom = &settings->video_viewport_custom;
if (!settings || !av_info)
return -1;
video_driver_get_viewport_info(&vp);
if (custom->height <= setting->min)
custom->height = setting->min;
else if (settings->bools.video_scale_integer)
{
struct retro_game_geometry *geom =
(struct retro_game_geometry*)&av_info->geometry;
unsigned int rotation = retroarch_get_rotation();
if (rotation % 2)
{
if (custom->height > geom->base_width)
custom->height -= geom->base_width;
}
else
{
if (custom->height > geom->base_height)
custom->height -= geom->base_height;
}
}
else
custom->height -= 1;
/* aspectratio_lut[ASPECT_RATIO_CUSTOM].value
* is updated in general_write_handler() */
return 0;
}
#if !defined(RARCH_CONSOLE)
static int setting_string_action_left_audio_device(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
int audio_device_index;
struct string_list *ptr = NULL;
if (!audio_driver_get_devices_list((void**)&ptr))
return -1;
if (!ptr)
return -1;
/* Get index in the string list */
audio_device_index = string_list_find_elem(
ptr, setting->value.target.string) - 1;
audio_device_index--;
/* Reset index if needed */
if (audio_device_index < -1)
audio_device_index = (int)(ptr->size - 1);
if (audio_device_index < 0)
strlcpy(setting->value.target.string,
"", setting->size);
else
strlcpy(setting->value.target.string,
ptr->elems[audio_device_index].data, setting->size);
command_event(CMD_EVENT_AUDIO_REINIT, NULL);
return 0;
}
#ifdef HAVE_MICROPHONE
static int setting_string_action_left_microphone_device(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
int mic_device_index;
struct string_list *ptr = NULL;
if (!microphone_driver_get_devices_list((void**)&ptr))
return -1;
if (!ptr)
return -1;
/* Get index in the string list */
mic_device_index = string_list_find_elem(
ptr, setting->value.target.string) - 1;
mic_device_index--;
/* Reset index if needed */
if (mic_device_index < -1)
mic_device_index = (int)(ptr->size - 1);
if (mic_device_index < 0)
strlcpy(setting->value.target.string,
"", setting->size);
else
strlcpy(setting->value.target.string,
ptr->elems[mic_device_index].data, setting->size);
command_event(CMD_EVENT_MICROPHONE_REINIT, NULL);
return 0;
}
#endif
#endif
static int setting_string_action_left_driver(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
driver_ctx_info_t drv;
bool success = false;
if (!setting)
return -1;
drv.label = setting->name;
drv.s = setting->value.target.string;
drv.len = setting->size;
/* Find the previous driver in the array of drivers.
* If the driver is protected, keep finding more previous drivers while the
* driver is null or until there are no more previous drivers. */
success = driver_ctl(RARCH_DRIVER_CTL_FIND_PREV, &drv);
if (setting_is_protected_driver(setting))
{
while (success &&
string_is_equal(drv.s, "null") &&
(success = driver_ctl(RARCH_DRIVER_CTL_FIND_PREV, &drv)));
}
if (!success)
{
settings_t *settings = config_get_ptr();
bool menu_navigation_wraparound_enable = settings ? settings->bools.menu_navigation_wraparound_enable: false;
if (menu_navigation_wraparound_enable)
{
/* If wraparound is enabled, find the LAST driver in the array of drivers.
* If the driver is protected, find the previous driver and keep finding more
* previous drivers while the driver is null or until there are no more previous drivers. */
drv.label = setting->name;
drv.s = setting->value.target.string;
drv.len = setting->size;
success = driver_ctl(RARCH_DRIVER_CTL_FIND_LAST, &drv);
if (setting_is_protected_driver(setting))
{
while (success &&
string_is_equal(drv.s, "null") &&
(success = driver_ctl(RARCH_DRIVER_CTL_FIND_PREV, &drv)));
}
}
else if (setting_is_protected_driver(setting))
{
/* If wraparound is disabled and if the driver is protected,
* find the next driver in the array of drivers and keep finding more
* next drivers while the driver is null or until there are no more next drivers. */
success = driver_ctl(RARCH_DRIVER_CTL_FIND_NEXT, &drv);
while (success &&
string_is_equal(drv.s, "null") &&
(success = driver_ctl(RARCH_DRIVER_CTL_FIND_NEXT, &drv)));
}
}
if (setting->change_handler)
setting->change_handler(setting);
return 0;
}
#ifdef HAVE_NETWORKING
static int setting_string_action_ok_netplay_mitm_server(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
char enum_idx[16];
if (!setting)
return -1;
snprintf(enum_idx, sizeof(enum_idx), "%d", setting->enum_idx);
generic_action_ok_displaylist_push(
enum_idx,
NULL, NULL, 0, idx, 0,
ACTION_OK_DL_DROPDOWN_BOX_LIST_NETPLAY_MITM_SERVER);
return 0;
}
static int setting_string_action_left_netplay_mitm_server(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
size_t i;
char *netplay_mitm_server;
ssize_t offset = -1;
if (!setting)
return -1;
netplay_mitm_server = setting->value.target.string;
for (i = 0; i < ARRAY_SIZE(netplay_mitm_server_list); i++)
{
const mitm_server_t *server = &netplay_mitm_server_list[i];
if (string_is_equal(server->name, netplay_mitm_server))
{
if (i > 0)
offset = i - 1;
else if (wraparound)
offset = ARRAY_SIZE(netplay_mitm_server_list) - 1;
else
offset = i;
break;
}
}
if (offset < 0)
offset = 0;
strlcpy(netplay_mitm_server, netplay_mitm_server_list[offset].name,
setting->size);
return 0;
}
static int setting_string_action_right_netplay_mitm_server(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
size_t i;
char *netplay_mitm_server;
ssize_t offset = -1;
if (!setting)
return -1;
netplay_mitm_server = setting->value.target.string;
for (i = 0; i < ARRAY_SIZE(netplay_mitm_server_list); i++)
{
const mitm_server_t *server = &netplay_mitm_server_list[i];
if (string_is_equal(server->name, netplay_mitm_server))
{
if (i < (ARRAY_SIZE(netplay_mitm_server_list) - 1))
offset = i + 1;
else if (wraparound)
offset = 0;
else
offset = i;
break;
}
}
if (offset < 0)
offset = ARRAY_SIZE(netplay_mitm_server_list) - 1;
strlcpy(netplay_mitm_server, netplay_mitm_server_list[offset].name,
setting->size);
return 0;
}
#endif
static int setting_uint_action_right_crt_switch_resolution_super(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
if (!setting)
return -1;
switch (*setting->value.target.unsigned_integer)
{
case 0:
*setting->value.target.unsigned_integer = 1;
break;
case 1: /* for dynamic super resolution switching - best fit */
*setting->value.target.unsigned_integer = 1920;
break;
case 1920:
*setting->value.target.unsigned_integer = 2560;
break;
case 2560:
*setting->value.target.unsigned_integer = 3840;
break;
case 3840:
*setting->value.target.unsigned_integer = 0;
break;
}
return 0;
}
static int setting_uint_action_right_custom_viewport_width(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
video_viewport_t vp;
settings_t *settings = config_get_ptr();
video_driver_state_t *video_st = video_state_get_ptr();
struct retro_system_av_info *av_info = &video_st->av_info;
video_viewport_t *custom = &settings->video_viewport_custom;
if (!settings || !av_info)
return -1;
video_driver_get_viewport_info(&vp);
if (custom->width >= setting->max)
custom->width = setting->max;
else if (settings->bools.video_scale_integer)
{
struct retro_game_geometry *geom = (struct retro_game_geometry*)
&av_info->geometry;
unsigned int rotation = retroarch_get_rotation();
if (rotation % 2)
custom->width += geom->base_height;
else
custom->width += geom->base_width;
}
else
custom->width += 1;
/* aspectratio_lut[ASPECT_RATIO_CUSTOM].value
* is updated in general_write_handler() */
return 0;
}
static int setting_uint_action_right_custom_viewport_height(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
video_viewport_t vp;
video_driver_state_t *video_st = video_state_get_ptr();
struct retro_system_av_info *av_info = &video_st->av_info;
settings_t *settings = config_get_ptr();
video_viewport_t *custom = &settings->video_viewport_custom;
if (!settings || !av_info)
return -1;
video_driver_get_viewport_info(&vp);
if (custom->height >= setting->max)
custom->height = setting->max;
else if (settings->bools.video_scale_integer)
{
struct retro_game_geometry *geom = (struct retro_game_geometry*)
&av_info->geometry;
unsigned int rotation = retroarch_get_rotation();
if (rotation % 2)
custom->height += geom->base_width;
else
custom->height += geom->base_height;
}
else
custom->height += 1;
/* aspectratio_lut[ASPECT_RATIO_CUSTOM].value
* is updated in general_write_handler() */
return 0;
}
#if !defined(RARCH_CONSOLE)
static int setting_string_action_right_audio_device(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
int audio_device_index;
struct string_list *ptr = NULL;
if (!audio_driver_get_devices_list((void**)&ptr))
return -1;
if (!ptr)
return -1;
/* Get index in the string list */
audio_device_index = string_list_find_elem(ptr,setting->value.target.string) - 1;
audio_device_index++;
/* Reset index if needed */
if (audio_device_index == (signed)ptr->size)
audio_device_index = -1;
if (audio_device_index < 0)
strlcpy(setting->value.target.string,
"", setting->size);
else
strlcpy(setting->value.target.string,
ptr->elems[audio_device_index].data, setting->size);
command_event(CMD_EVENT_AUDIO_REINIT, NULL);
return 0;
}
#ifdef HAVE_MICROPHONE
static int setting_string_action_right_microphone_device(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
int mic_device_index;
struct string_list *ptr = NULL;
if (!microphone_driver_get_devices_list((void**)&ptr))
return -1;
if (!ptr)
return -1;
/* Get index in the string list */
mic_device_index = string_list_find_elem(ptr,setting->value.target.string) - 1;
mic_device_index++;
/* Reset index if needed */
if (mic_device_index == (signed)ptr->size)
mic_device_index = -1;
if (mic_device_index < 0)
strlcpy(setting->value.target.string,
"", setting->size);
else
strlcpy(setting->value.target.string,
ptr->elems[mic_device_index].data, setting->size);
command_event(CMD_EVENT_MICROPHONE_REINIT, NULL);
return 0;
}
#endif
#endif
static int setting_string_action_right_driver(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
driver_ctx_info_t drv;
bool success = false;
if (!setting)
return -1;
drv.label = setting->name;
drv.s = setting->value.target.string;
drv.len = setting->size;
/* Find the next driver in the array of drivers.
* If the driver is protected, keep finding next drivers while the
* driver is null or until there are no more next drivers. */
success = driver_ctl(RARCH_DRIVER_CTL_FIND_NEXT, &drv);
if (setting_is_protected_driver(setting))
{
while (success &&
string_is_equal(drv.s, "null") &&
(success = driver_ctl(RARCH_DRIVER_CTL_FIND_NEXT, &drv)));
}
if (!success)
{
settings_t *settings = config_get_ptr();
bool menu_navigation_wraparound_enable = settings ? settings->bools.menu_navigation_wraparound_enable: false;
if (menu_navigation_wraparound_enable)
{
/* If wraparound is enabled, find the first driver in the array of drivers.
* If the driver is protected, find the next driver and keep finding more
* next drivers while the driver is null or until there are no more next drivers. */
drv.label = setting->name;
drv.s = setting->value.target.string;
drv.len = setting->size;
success = driver_ctl(RARCH_DRIVER_CTL_FIND_FIRST, &drv);
if (setting_is_protected_driver(setting))
{
while (success &&
string_is_equal(drv.s, "null") &&
(success = driver_ctl(RARCH_DRIVER_CTL_FIND_NEXT, &drv)));
}
}
else if (setting_is_protected_driver(setting))
{
/* If wraparound is disabled and if the driver is protected,
* find the previous driver in the array of drivers and keep finding more
* previous drivers while the driver is null or until there are no more previous drivers. */
success = driver_ctl(RARCH_DRIVER_CTL_FIND_PREV, &drv);
while (success &&
string_is_equal(drv.s, "null") &&
(success = driver_ctl(RARCH_DRIVER_CTL_FIND_PREV, &drv)));
}
}
if (setting->change_handler)
setting->change_handler(setting);
return 0;
}
static int setting_string_action_left_midi_input(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
struct string_list *list = midi_driver_get_avail_inputs();
if (list && list->size > 1)
{
int i = string_list_find_elem(list, setting->value.target.string) - 2;
if (wraparound && i == -1)
i = (int)list->size - 1;
if (i >= 0)
{
strlcpy(setting->value.target.string,
list->elems[i].data, setting->size);
return 0;
}
}
return -1;
}
static int setting_string_action_right_midi_input(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
struct string_list *list = midi_driver_get_avail_inputs();
if (list && list->size > 1)
{
int i = string_list_find_elem(list, setting->value.target.string);
if (wraparound && i == (int)list->size)
i = 0;
if (i >= 0 && i < (int)list->size)
{
strlcpy(setting->value.target.string,
list->elems[i].data, setting->size);
return 0;
}
}
return -1;
}
static int setting_string_action_left_midi_output(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
struct string_list *list = midi_driver_get_avail_outputs();
if (list && list->size > 1)
{
int i = string_list_find_elem(list, setting->value.target.string) - 2;
if (wraparound && i == -1)
i = (int)list->size - 1;
if (i >= 0)
{
strlcpy(setting->value.target.string,
list->elems[i].data, setting->size);
return 0;
}
}
return -1;
}
static int setting_string_action_right_midi_output(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
struct string_list *list = midi_driver_get_avail_outputs();
if (list && list->size > 1)
{
int i = string_list_find_elem(list, setting->value.target.string);
if (wraparound && i == (int)list->size)
i = 0;
if (i >= 0 && i < (int)list->size)
{
strlcpy(setting->value.target.string,
list->elems[i].data, setting->size);
return 0;
}
}
return -1;
}
#ifdef HAVE_CHEATS
static void setting_get_string_representation_uint_cheat_exact(rarch_setting_t *setting,
char *s, size_t len)
{
if (setting)
snprintf(s, len, msg_hash_to_str(MENU_ENUM_LABEL_CHEAT_SEARCH_EXACT_VAL),
*setting->value.target.unsigned_integer, *setting->value.target.unsigned_integer);
}
static void setting_get_string_representation_uint_cheat_lt(rarch_setting_t *setting,
char *s, size_t len)
{
if (setting)
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_CHEAT_SEARCH_LT_VAL), len);
}
static void setting_get_string_representation_uint_cheat_gt(rarch_setting_t *setting,
char *s, size_t len)
{
if (setting)
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_CHEAT_SEARCH_GT_VAL), len);
}
static void setting_get_string_representation_uint_cheat_lte(rarch_setting_t *setting,
char *s, size_t len)
{
if (setting)
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_CHEAT_SEARCH_LTE_VAL), len);
}
static void setting_get_string_representation_uint_cheat_gte(rarch_setting_t *setting,
char *s, size_t len)
{
if (setting)
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_CHEAT_SEARCH_GTE_VAL), len);
}
static void setting_get_string_representation_uint_cheat_eq(rarch_setting_t *setting,
char *s, size_t len)
{
if (setting)
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_CHEAT_SEARCH_EQ_VAL), len);
}
static void setting_get_string_representation_uint_cheat_neq(rarch_setting_t *setting,
char *s, size_t len)
{
if (setting)
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_CHEAT_SEARCH_NEQ_VAL), len);
}
static void setting_get_string_representation_uint_cheat_eqplus(rarch_setting_t *setting,
char *s, size_t len)
{
if (setting)
snprintf(s, len, msg_hash_to_str(MENU_ENUM_LABEL_CHEAT_SEARCH_EQPLUS_VAL),
*setting->value.target.unsigned_integer, *setting->value.target.unsigned_integer);
}
static void setting_get_string_representation_uint_cheat_eqminus(rarch_setting_t *setting,
char *s, size_t len)
{
if (setting)
snprintf(s, len, msg_hash_to_str(MENU_ENUM_LABEL_CHEAT_SEARCH_EQMINUS_VAL),
*setting->value.target.unsigned_integer, *setting->value.target.unsigned_integer);
}
static void setting_get_string_representation_uint_cheat_browse_address(
rarch_setting_t *setting,
char *s, size_t len)
{
unsigned int address = cheat_manager_state.browse_address;
unsigned int address_mask = 0;
unsigned int prev_val = 0;
unsigned int curr_val = 0;
if (setting)
snprintf(s, len, msg_hash_to_str(MENU_ENUM_LABEL_CHEAT_SEARCH_EQMINUS_VAL),
*setting->value.target.unsigned_integer, *setting->value.target.unsigned_integer);
cheat_manager_match_action(CHEAT_MATCH_ACTION_TYPE_BROWSE, cheat_manager_state.match_idx, &address, &address_mask, &prev_val, &curr_val);
snprintf(s, len, "Prev: %u Curr: %u", prev_val, curr_val);
}
#endif
static void setting_get_string_representation_video_swap_interval(rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
if (*setting->value.target.unsigned_integer == 0)
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SWAP_INTERVAL_AUTO), len);
else
snprintf(s, len, "%u", *setting->value.target.unsigned_integer);
}
static void setting_get_string_representation_black_frame_insertion(rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case 0:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_BLACK_FRAME_INSERTION_VALUE_OFF), len);
break;
case 1:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_BLACK_FRAME_INSERTION_VALUE_120), len);
break;
case 2:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_BLACK_FRAME_INSERTION_VALUE_180), len);
break;
case 3:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_BLACK_FRAME_INSERTION_VALUE_240), len);
break;
case 4:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_BLACK_FRAME_INSERTION_VALUE_300), len);
break;
case 5:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_BLACK_FRAME_INSERTION_VALUE_360), len);
break;
case 6:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_BLACK_FRAME_INSERTION_VALUE_420), len);
break;
case 7:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_BLACK_FRAME_INSERTION_VALUE_480), len);
break;
case 8:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_BLACK_FRAME_INSERTION_VALUE_540), len);
break;
case 9:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_BLACK_FRAME_INSERTION_VALUE_600), len);
break;
case 10:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_BLACK_FRAME_INSERTION_VALUE_660), len);
break;
case 11:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_BLACK_FRAME_INSERTION_VALUE_720), len);
break;
case 12:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_BLACK_FRAME_INSERTION_VALUE_780), len);
break;
case 13:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_BLACK_FRAME_INSERTION_VALUE_840), len);
break;
case 14:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_BLACK_FRAME_INSERTION_VALUE_900), len);
break;
case 15:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_BLACK_FRAME_INSERTION_VALUE_960), len);
break;
}
}
static void setting_get_string_representation_shader_subframes(rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case 1:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_SUBFRAMES_VALUE_OFF), len);
break;
case 2:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_SUBFRAMES_VALUE_120), len);
break;
case 3:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_SUBFRAMES_VALUE_180), len);
break;
case 4:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_SUBFRAMES_VALUE_240), len);
break;
case 5:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_SUBFRAMES_VALUE_300), len);
break;
case 6:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_SUBFRAMES_VALUE_360), len);
break;
case 7:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_SUBFRAMES_VALUE_420), len);
break;
case 8:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_SUBFRAMES_VALUE_480), len);
break;
case 9:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_SUBFRAMES_VALUE_540), len);
break;
case 10:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_SUBFRAMES_VALUE_600), len);
break;
case 11:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_SUBFRAMES_VALUE_660), len);
break;
case 12:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_SUBFRAMES_VALUE_720), len);
break;
case 13:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_SUBFRAMES_VALUE_780), len);
break;
case 14:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_SUBFRAMES_VALUE_840), len);
break;
case 15:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_SUBFRAMES_VALUE_900), len);
break;
case 16:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_SUBFRAMES_VALUE_960), len);
break;
}
}
static void setting_get_string_representation_video_frame_delay(rarch_setting_t *setting,
char *s, size_t len)
{
settings_t *settings = config_get_ptr();
if (!setting)
return;
if (settings && settings->bools.video_frame_delay_auto)
{
video_driver_state_t *video_st = video_state_get_ptr();
struct menu_state *menu_st = menu_state_get_ptr();
file_list_t *menu_stack = MENU_LIST_GET(menu_st->entries.list, 0);
const char *label = NULL;
if (menu_stack && menu_stack->size)
label = menu_stack->list[menu_stack->size - 1].label;
if (*setting->value.target.unsigned_integer == 0)
{
size_t _len = strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_FRAME_DELAY_AUTOMATIC), len);
if (!string_is_equal(label, msg_hash_to_str(MENU_ENUM_LABEL_DEFERRED_DROPDOWN_BOX_LIST)))
snprintf(s + _len, len - _len, " (%u %s)",
video_st->frame_delay_effective,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_FRAME_DELAY_EFFECTIVE));
}
else
{
if (string_is_equal(label, msg_hash_to_str(MENU_ENUM_LABEL_DEFERRED_DROPDOWN_BOX_LIST)))
snprintf(s, len, "%u",
*setting->value.target.unsigned_integer);
else
snprintf(s, len, "%u (%u %s)",
*setting->value.target.unsigned_integer,
video_st->frame_delay_effective,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_FRAME_DELAY_EFFECTIVE));
}
}
else
snprintf(s, len, "%u", *setting->value.target.unsigned_integer);
}
static void setting_get_string_representation_uint_video_rotation(rarch_setting_t *setting,
char *s, size_t len)
{
if (setting)
{
switch (*setting->value.target.unsigned_integer)
{
case VIDEO_ROTATION_NORMAL:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_ROTATION_NORMAL),
len);
break;
case VIDEO_ROTATION_90_DEG:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_ROTATION_90_DEG),
len);
break;
case VIDEO_ROTATION_180_DEG:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_ROTATION_180_DEG),
len);
break;
case VIDEO_ROTATION_270_DEG:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_ROTATION_270_DEG),
len);
break;
}
}
}
static void setting_get_string_representation_uint_screen_orientation(rarch_setting_t *setting,
char *s, size_t len)
{
if (setting)
{
switch (*setting->value.target.unsigned_integer)
{
case ORIENTATION_NORMAL:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_ORIENTATION_NORMAL),
len);
break;
case ORIENTATION_VERTICAL:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_ORIENTATION_VERTICAL),
len);
break;
case ORIENTATION_FLIPPED:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_ORIENTATION_FLIPPED),
len);
break;
case ORIENTATION_FLIPPED_ROTATED:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_ORIENTATION_FLIPPED_ROTATED),
len);
break;
}
}
}
static void setting_get_string_representation_uint_aspect_ratio_index(
rarch_setting_t *setting,
char *s, size_t len)
{
if (setting)
strlcpy(s,
aspectratio_lut[*setting->value.target.unsigned_integer].name,
len);
}
static void setting_get_string_representation_uint_crt_switch_resolutions(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case CRT_SWITCH_NONE:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF), len);
break;
case CRT_SWITCH_15KHZ:
strlcpy(s, "15 KHz", len);
break;
case CRT_SWITCH_31KHZ:
strlcpy(s, "31 KHz, Standard", len);
break;
case CRT_SWITCH_32_120:
strlcpy(s, "31 KHz, 120Hz", len);
break;
case CRT_SWITCH_INI:
strlcpy(s, "INI", len);
break;
}
}
static void setting_get_string_representation_uint_audio_resampler_quality(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case RESAMPLER_QUALITY_DONTCARE:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_DONT_CARE),
len);
break;
case RESAMPLER_QUALITY_LOWEST:
strlcpy(s, msg_hash_to_str(MSG_RESAMPLER_QUALITY_LOWEST),
len);
break;
case RESAMPLER_QUALITY_LOWER:
strlcpy(s, msg_hash_to_str(MSG_RESAMPLER_QUALITY_LOWER),
len);
break;
case RESAMPLER_QUALITY_HIGHER:
strlcpy(s, msg_hash_to_str(MSG_RESAMPLER_QUALITY_HIGHER),
len);
break;
case RESAMPLER_QUALITY_HIGHEST:
strlcpy(s, msg_hash_to_str(MSG_RESAMPLER_QUALITY_HIGHEST),
len);
break;
case RESAMPLER_QUALITY_NORMAL:
strlcpy(s, msg_hash_to_str(MSG_RESAMPLER_QUALITY_NORMAL),
len);
break;
}
}
static void setting_get_string_representation_uint_libretro_device(
rarch_setting_t *setting,
char *s, size_t len)
{
unsigned index_offset, device;
const struct retro_controller_description *desc = NULL;
const char *name = NULL;
rarch_system_info_t *sys_info = &runloop_state_get_ptr()->system;
if (!setting)
return;
index_offset = setting->index_offset;
device = input_config_get_device(index_offset);
if (sys_info)
{
if (index_offset < sys_info->ports.size)
desc = libretro_find_controller_description(
&sys_info->ports.data[index_offset],
device);
}
if (desc)
name = desc->desc;
if (!name)
{
/* Find generic name. */
switch (device)
{
case RETRO_DEVICE_NONE:
name = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NONE);
break;
case RETRO_DEVICE_JOYPAD:
name = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_RETROPAD);
break;
case RETRO_DEVICE_ANALOG:
name = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_RETROPAD_WITH_ANALOG);
break;
default:
name = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_UNKNOWN);
break;
}
}
if (!string_is_empty(name))
strlcpy(s, name, len);
}
static void setting_get_string_representation_uint_analog_dpad_mode(
rarch_setting_t *setting,
char *s, size_t len)
{
const char *modes[5];
modes[0] = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NONE);
modes[1] = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_LEFT_ANALOG);
modes[2] = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_RIGHT_ANALOG);
modes[3] = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_LEFT_ANALOG_FORCED);
modes[4] = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_RIGHT_ANALOG_FORCED);
strlcpy(s, modes[*setting->value.target.unsigned_integer % ANALOG_DPAD_LAST], len);
}
static void setting_get_string_representation_uint_input_remap_port(
rarch_setting_t *setting,
char *s, size_t len)
{
if (setting)
snprintf(s, len, "%u", *setting->value.target.unsigned_integer + 1);
}
#ifdef HAVE_THREADS
static void setting_get_string_representation_uint_autosave_interval(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
if (*setting->value.target.unsigned_integer)
{
size_t _len = snprintf(s, len, "%u ", *setting->value.target.unsigned_integer);
strlcpy(s + _len, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_SECONDS), len - _len);
}
else
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF), len);
}
#endif
#ifdef HAVE_BSV_MOVIE
static void setting_get_string_representation_uint_replay_checkpoint_interval(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
if (*setting->value.target.unsigned_integer)
{
size_t _len = snprintf(s, len, "%u ", *setting->value.target.unsigned_integer);
strlcpy(s + _len, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_SECONDS), len - _len);
}
else
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF), len);
}
#endif
#if defined(HAVE_NETWORKING)
static void setting_get_string_representation_netplay_mitm_server(
rarch_setting_t *setting,
char *s, size_t len)
{
}
static void setting_get_string_representation_netplay_share_digital(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case RARCH_NETPLAY_SHARE_DIGITAL_NO_PREFERENCE:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NETPLAY_SHARE_NO_PREFERENCE), len);
break;
case RARCH_NETPLAY_SHARE_DIGITAL_OR:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NETPLAY_SHARE_DIGITAL_OR), len);
break;
case RARCH_NETPLAY_SHARE_DIGITAL_XOR:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NETPLAY_SHARE_DIGITAL_XOR), len);
break;
case RARCH_NETPLAY_SHARE_DIGITAL_VOTE:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NETPLAY_SHARE_DIGITAL_VOTE), len);
break;
default:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NETPLAY_SHARE_NONE), len);
break;
}
}
static void setting_get_string_representation_netplay_share_analog(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case RARCH_NETPLAY_SHARE_ANALOG_NO_PREFERENCE:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NETPLAY_SHARE_NO_PREFERENCE), len);
break;
case RARCH_NETPLAY_SHARE_ANALOG_MAX:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NETPLAY_SHARE_ANALOG_MAX), len);
break;
case RARCH_NETPLAY_SHARE_ANALOG_AVERAGE:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NETPLAY_SHARE_ANALOG_AVERAGE), len);
break;
default:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NETPLAY_SHARE_NONE), len);
break;
}
}
#endif
static void setting_get_string_representation_gamepad_combo(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case INPUT_COMBO_NONE:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NONE), len);
break;
case INPUT_COMBO_DOWN_Y_L_R:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_DOWN_Y_L_R), len);
break;
case INPUT_COMBO_L3_R3:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_L3_R3), len);
break;
case INPUT_COMBO_L1_R1_START_SELECT:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_L1_R1_START_SELECT), len);
break;
case INPUT_COMBO_START_SELECT:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_START_SELECT), len);
break;
case INPUT_COMBO_L3_R:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_L3_R), len);
break;
case INPUT_COMBO_L_R:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_L_R), len);
break;
case INPUT_COMBO_HOLD_START:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_HOLD_START), len);
break;
case INPUT_COMBO_HOLD_SELECT:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_HOLD_SELECT), len);
break;
case INPUT_COMBO_DOWN_SELECT:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_DOWN_SELECT), len);
break;
case INPUT_COMBO_L2_R2:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_L2_R2), len);
break;
}
}
static void setting_get_string_representation_turbo_mode(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case INPUT_TURBO_MODE_CLASSIC:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_TURBO_MODE_CLASSIC), len);
break;
case INPUT_TURBO_MODE_CLASSIC_TOGGLE:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_TURBO_MODE_CLASSIC_TOGGLE), len);
break;
case INPUT_TURBO_MODE_SINGLEBUTTON:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_TURBO_MODE_SINGLEBUTTON), len);
break;
case INPUT_TURBO_MODE_SINGLEBUTTON_HOLD:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_TURBO_MODE_SINGLEBUTTON_HOLD), len);
break;
}
}
static void setting_get_string_representation_turbo_default_button(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case INPUT_TURBO_DEFAULT_BUTTON_B:
strlcpy(s, "B", len);
break;
case INPUT_TURBO_DEFAULT_BUTTON_Y:
strlcpy(s, "Y", len);
break;
case INPUT_TURBO_DEFAULT_BUTTON_A:
strlcpy(s, "A", len);
break;
case INPUT_TURBO_DEFAULT_BUTTON_X:
strlcpy(s, "X", len);
break;
case INPUT_TURBO_DEFAULT_BUTTON_L:
strlcpy(s, "L", len);
break;
case INPUT_TURBO_DEFAULT_BUTTON_R:
strlcpy(s, "R", len);
break;
case INPUT_TURBO_DEFAULT_BUTTON_L2:
strlcpy(s, "L2", len);
break;
case INPUT_TURBO_DEFAULT_BUTTON_R2:
strlcpy(s, "R2", len);
break;
case INPUT_TURBO_DEFAULT_BUTTON_L3:
strlcpy(s, "L3", len);
break;
case INPUT_TURBO_DEFAULT_BUTTON_R3:
strlcpy(s, "R3", len);
break;
}
}
static void setting_get_string_representation_poll_type_behavior(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case 0:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_INPUT_POLL_TYPE_BEHAVIOR_EARLY), len);
break;
case 1:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_INPUT_POLL_TYPE_BEHAVIOR_NORMAL), len);
break;
case 2:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_INPUT_POLL_TYPE_BEHAVIOR_LATE), len);
break;
}
}
static void setting_get_string_representation_input_touch_scale(rarch_setting_t *setting,
char *s, size_t len)
{
if (setting)
snprintf(s, len, "x%d", *setting->value.target.unsigned_integer);
}
#ifdef ANDROID
static void setting_get_string_representation_android_physical_keyboard(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
settings_t *settings = config_get_ptr();
int keyboard_vendor_id;
int keyboard_product_id;
if (sscanf(setting->value.target.string, "%04x:%04x ", &keyboard_vendor_id, &keyboard_product_id) != 2)
strlcpy(s, setting->value.target.string, len);
else
strlcpy(s, &setting->value.target.string[10], len);
}
#endif
#ifdef HAVE_LANGEXTRA
static void setting_get_string_representation_uint_user_language(
rarch_setting_t *setting,
char *s, size_t len)
{
const char *modes[RETRO_LANGUAGE_LAST];
uint32_t translated[RETRO_LANGUAGE_LAST];
#define LANG_DATA(STR) \
modes[RETRO_LANGUAGE_##STR] = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_LANG_##STR); \
translated[RETRO_LANGUAGE_##STR] = LANGUAGE_PROGRESS_##STR##_TRANSLATED; \
modes[RETRO_LANGUAGE_ENGLISH] = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_LANG_ENGLISH);
LANG_DATA(JAPANESE)
LANG_DATA(FRENCH)
LANG_DATA(SPANISH)
LANG_DATA(GERMAN)
LANG_DATA(ITALIAN)
LANG_DATA(DUTCH)
modes[RETRO_LANGUAGE_PORTUGUESE_BRAZIL] = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_LANG_PORTUGUESE_BRAZIL);
translated[RETRO_LANGUAGE_PORTUGUESE_BRAZIL] = LANGUAGE_PROGRESS_PORTUGUESE_BRAZILIAN_TRANSLATED;
modes[RETRO_LANGUAGE_PORTUGUESE_PORTUGAL] = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_LANG_PORTUGUESE_PORTUGAL);
translated[RETRO_LANGUAGE_PORTUGUESE_PORTUGAL] = LANGUAGE_PROGRESS_PORTUGUESE_TRANSLATED;
LANG_DATA(RUSSIAN)
LANG_DATA(KOREAN)
LANG_DATA(CHINESE_TRADITIONAL)
LANG_DATA(CHINESE_SIMPLIFIED)
LANG_DATA(ESPERANTO)
LANG_DATA(POLISH)
LANG_DATA(VIETNAMESE)
LANG_DATA(ARABIC)
LANG_DATA(GREEK)
LANG_DATA(TURKISH)
LANG_DATA(SLOVAK)
LANG_DATA(PERSIAN)
LANG_DATA(HEBREW)
LANG_DATA(ASTURIAN)
LANG_DATA(FINNISH)
LANG_DATA(INDONESIAN)
LANG_DATA(SWEDISH)
LANG_DATA(UKRAINIAN)
LANG_DATA(CZECH)
modes[RETRO_LANGUAGE_CATALAN_VALENCIA] = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_LANG_CATALAN_VALENCIA);
translated[RETRO_LANGUAGE_CATALAN_VALENCIA] = LANGUAGE_PROGRESS_VALENCIAN_TRANSLATED;
LANG_DATA(CATALAN)
modes[RETRO_LANGUAGE_BRITISH_ENGLISH] = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_LANG_BRITISH_ENGLISH);
translated[RETRO_LANGUAGE_BRITISH_ENGLISH] = LANGUAGE_PROGRESS_ENGLISH_UNITED_KINGDOM_TRANSLATED;
LANG_DATA(HUNGARIAN)
LANG_DATA(BELARUSIAN)
if (*msg_hash_get_uint(MSG_HASH_USER_LANGUAGE) == RETRO_LANGUAGE_ENGLISH)
strlcpy(s, modes[*msg_hash_get_uint(MSG_HASH_USER_LANGUAGE)], len);
else
{
const char *rating = msg_hash_to_str(
translated[*msg_hash_get_uint(MSG_HASH_USER_LANGUAGE)] > 95 ? MENU_ENUM_LABEL_VALUE_LNG_COMPLETION_95_PLUS :
translated[*msg_hash_get_uint(MSG_HASH_USER_LANGUAGE)] > 74 ? MENU_ENUM_LABEL_VALUE_LNG_COMPLETION_75_PLUS :
translated[*msg_hash_get_uint(MSG_HASH_USER_LANGUAGE)] > 49 ? MENU_ENUM_LABEL_VALUE_LNG_COMPLETION_50_PLUS :
translated[*msg_hash_get_uint(MSG_HASH_USER_LANGUAGE)] > 24 ? MENU_ENUM_LABEL_VALUE_LNG_COMPLETION_25_PLUS :
MENU_ENUM_LABEL_VALUE_LNG_COMPLETION_25_MINUS);
snprintf(s, len, "%s [%s]",
modes[*msg_hash_get_uint(MSG_HASH_USER_LANGUAGE)], rating);
}
}
#endif
static void setting_get_string_representation_uint_libretro_log_level(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case 0:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_LOG_VERBOSITY_DEBUG), len);
break;
case 1:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_LOG_VERBOSITY_INFO), len);
break;
case 2:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_LOG_VERBOSITY_WARNING), len);
break;
case 3:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_LOG_VERBOSITY_ERROR), len);
break;
}
}
static void setting_get_string_representation_uint_quit_on_close_content(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case QUIT_ON_CLOSE_CONTENT_DISABLED:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF), len);
break;
case QUIT_ON_CLOSE_CONTENT_ENABLED:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_ON), len);
break;
case QUIT_ON_CLOSE_CONTENT_CLI:
strlcpy(s, "CLI", len);
break;
}
}
static void setting_get_string_representation_uint_playlist_show_history_icons(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case PLAYLIST_SHOW_HISTORY_ICONS_DEFAULT:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_DONT_CARE), len);
break;
case PLAYLIST_SHOW_HISTORY_ICONS_MAIN:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_MAIN), len);
break;
case PLAYLIST_SHOW_HISTORY_ICONS_CONTENT:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_CONTENT), len);
break;
}
}
static void setting_get_string_representation_uint_menu_screensaver_timeout(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
if (*setting->value.target.unsigned_integer == 0)
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF), len);
else
{
size_t _len = snprintf(s, len, "%u ", *setting->value.target.unsigned_integer);
strlcpy(s + _len, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_SECONDS), len - _len);
}
}
#if defined(HAVE_MATERIALUI) || defined(HAVE_XMB) || defined(HAVE_OZONE)
static void setting_get_string_representation_uint_menu_screensaver_animation(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case MENU_SCREENSAVER_BLANK:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_OFF),
len);
break;
case MENU_SCREENSAVER_SNOW:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MENU_SCREENSAVER_ANIMATION_SNOW),
len);
break;
case MENU_SCREENSAVER_STARFIELD:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MENU_SCREENSAVER_ANIMATION_STARFIELD),
len);
break;
case MENU_SCREENSAVER_VORTEX:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MENU_SCREENSAVER_ANIMATION_VORTEX),
len);
break;
}
}
#endif
#if defined(HAVE_XMB) || defined(HAVE_OZONE) || defined(HAVE_RGUI)
static void setting_get_string_representation_uint_menu_remember_selection(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case MENU_REMEMBER_SELECTION_ALWAYS:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MENU_REMEMBER_SELECTION_ALWAYS),
len);
break;
case MENU_REMEMBER_SELECTION_PLAYLISTS:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MENU_REMEMBER_SELECTION_PLAYLISTS),
len);
break;
case MENU_REMEMBER_SELECTION_MAIN:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_MENU_REMEMBER_SELECTION_MAIN),
len);
break;
case MENU_REMEMBER_SELECTION_OFF:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_OFF),
len);
break;
}
}
#endif
#ifdef HAVE_MIST
static void setting_get_string_representation_steam_rich_presence_format(
rarch_setting_t *setting,
char *s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case STEAM_RICH_PRESENCE_FORMAT_CONTENT:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_STEAM_RICH_PRESENCE_FORMAT_CONTENT), len);
break;
case STEAM_RICH_PRESENCE_FORMAT_CORE:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_STEAM_RICH_PRESENCE_FORMAT_CORE), len);
break;
case STEAM_RICH_PRESENCE_FORMAT_SYSTEM:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_STEAM_RICH_PRESENCE_FORMAT_SYSTEM), len);
break;
case STEAM_RICH_PRESENCE_FORMAT_CONTENT_SYSTEM:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_STEAM_RICH_PRESENCE_FORMAT_CONTENT_SYSTEM), len);
break;
case STEAM_RICH_PRESENCE_FORMAT_CONTENT_CORE:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_STEAM_RICH_PRESENCE_FORMAT_CONTENT_CORE), len);
break;
case STEAM_RICH_PRESENCE_FORMAT_CONTENT_SYSTEM_CORE:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_STEAM_RICH_PRESENCE_FORMAT_CONTENT_SYSTEM_CORE), len);
break;
case STEAM_RICH_PRESENCE_FORMAT_NONE:
default:
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NONE), len);
break;
}
}
#endif
enum setting_type menu_setting_get_browser_selection_type(rarch_setting_t *setting)
{
if (!setting)
return ST_NONE;
return setting->browser_selection_type;
}
static void menu_settings_list_current_add_range(
rarch_setting_t **list,
rarch_setting_info_t *list_info,
float min, float max, float step,
bool enforce_minrange_enable, bool enforce_maxrange_enable)
{
unsigned idx = list_info->index - 1;
if ((*list)[idx].type == ST_FLOAT)
(*list)[idx].ui_type = ST_UI_TYPE_FLOAT_SLIDER_AND_SPINBOX;
(*list)[idx].min = min;
(*list)[idx].step = step;
(*list)[idx].max = max;
if (enforce_minrange_enable)
(*list)[idx].flags |= SD_FLAG_ENFORCE_MINRANGE;
if (enforce_maxrange_enable)
(*list)[idx].flags |= SD_FLAG_ENFORCE_MAXRANGE;
(*list)[idx].flags |= SD_FLAG_HAS_RANGE;
}
int menu_setting_generic(rarch_setting_t *setting, size_t idx, bool wraparound)
{
uint32_t flags = setting->flags;
if (setting_generic_action_ok_default(setting, idx, wraparound) != 0)
return -1;
if (setting->change_handler)
setting->change_handler(setting);
if ((flags & SD_FLAG_EXIT) && (flags & SD_FLAG_CMD_TRIGGER_EVENT_TRIGGERED))
{
setting->flags &= ~SD_FLAG_CMD_TRIGGER_EVENT_TRIGGERED;
return -1;
}
return 0;
}
int menu_action_handle_setting(rarch_setting_t *setting,
unsigned type, unsigned action, bool wraparound)
{
if (!setting)
return -1;
switch (setting->type)
{
case ST_PATH:
if (action == MENU_ACTION_OK)
{
menu_displaylist_info_t info;
settings_t *settings = config_get_ptr();
struct menu_state *menu_st = menu_state_get_ptr();
menu_list_t *menu_list = menu_st->entries.list;
file_list_t *menu_stack = MENU_LIST_GET(menu_list, 0);
const char *name = setting->name;
size_t selection = menu_st->selection_ptr;
menu_displaylist_info_init(&info);
info.path = strdup(setting->default_value.string);
info.label = strdup(name);
info.type = type;
info.directory_ptr = selection;
info.list = menu_stack;
/* Menu background image */
if (string_is_equal(info.label, msg_hash_to_str(MENU_ENUM_LABEL_MENU_WALLPAPER)))
{
/* Start from current wallpaper instead if available */
if (!string_is_empty(settings->paths.path_menu_wallpaper))
{
free(info.path);
info.path = strdup(settings->paths.path_menu_wallpaper);
}
}
/* Browse basedir instead and set selection to file if available */
if (!string_is_empty(info.path) && !path_is_directory(info.path))
{
const char *selection_path = path_basename(info.path);
if (!string_is_empty(selection_path))
menu_driver_set_pending_selection(selection_path);
path_basedir(info.path);
}
if (menu_displaylist_ctl(DISPLAYLIST_GENERIC, &info, settings))
menu_displaylist_process(&info);
menu_displaylist_info_free(&info);
}
/* fall-through. */
case ST_BOOL:
case ST_INT:
case ST_UINT:
case ST_SIZE:
case ST_FLOAT:
case ST_STRING:
case ST_STRING_OPTIONS:
case ST_DIR:
case ST_BIND:
case ST_ACTION:
{
int ret = -1;
struct menu_state *menu_st = menu_state_get_ptr();
size_t selection = menu_st->selection_ptr;
switch (action)
{
case MENU_ACTION_UP:
if (setting->action_up)
ret = setting->action_up(setting);
break;
case MENU_ACTION_DOWN:
if (setting->action_down)
ret = setting->action_down(setting);
break;
case MENU_ACTION_LEFT:
if (setting->action_left)
{
ret = setting->action_left(setting, selection, false);
if (menu_st->driver_ctx)
{
if (menu_st->driver_ctx->update_savestate_thumbnail_path)
menu_st->driver_ctx->update_savestate_thumbnail_path(
menu_st->userdata, (unsigned)selection);
if (menu_st->driver_ctx->update_savestate_thumbnail_image)
menu_st->driver_ctx->update_savestate_thumbnail_image(
menu_st->userdata);
}
}
break;
case MENU_ACTION_RIGHT:
if (setting->action_right)
{
ret = setting->action_right(setting, selection, false);
if (menu_st->driver_ctx)
{
if (menu_st->driver_ctx->update_savestate_thumbnail_path)
menu_st->driver_ctx->update_savestate_thumbnail_path(
menu_st->userdata, (unsigned)selection);
if (menu_st->driver_ctx->update_savestate_thumbnail_image)
menu_st->driver_ctx->update_savestate_thumbnail_image(
menu_st->userdata);
}
}
break;
case MENU_ACTION_SELECT:
if (setting->action_select)
ret = setting->action_select(setting, selection, true);
break;
case MENU_ACTION_OK:
if (setting->action_ok)
ret = setting->action_ok(setting, selection, false);
break;
case MENU_ACTION_CANCEL:
if (setting->action_cancel)
ret = setting->action_cancel(setting);
break;
case MENU_ACTION_START:
if (setting->action_start)
ret = setting->action_start(setting);
break;
}
if (ret == 0)
return menu_setting_generic(setting, selection, wraparound);
}
break;
default:
break;
}
return -1;
}
/**
* menu_setting_find:
* @settings : pointer to settings
* @name : name of setting to search for
*
* Search for a setting with a specified name (@name).
*
* Returns: pointer to setting if found, NULL otherwise.
**/
rarch_setting_t *menu_setting_find(const char *label)
{
rarch_setting_t *setting = NULL;
rarch_setting_t **list = &setting;
struct menu_state *menu_st;
if (!label)
return NULL;
menu_st = menu_state_get_ptr();
setting = menu_st->entries.list_settings;
if (!setting)
return NULL;
for (; setting->type != ST_NONE; (*list = *list + 1))
{
const char *name = setting->name;
const char *short_description = setting->short_description;
if (
string_is_equal(label, name) &&
(setting->type <= ST_GROUP))
{
if (string_is_empty(short_description))
break;
if (setting->read_handler)
setting->read_handler(setting);
return setting;
}
}
return NULL;
}
rarch_setting_t *menu_setting_find_enum(enum msg_hash_enums enum_idx)
{
rarch_setting_t *setting = NULL;
rarch_setting_t **list = &setting;
struct menu_state *menu_st = NULL;
if (enum_idx == 0)
return NULL;
menu_st = menu_state_get_ptr();
setting = menu_st->entries.list_settings;
if (!setting)
return NULL;
for (; setting->type != ST_NONE; (*list = *list + 1))
{
if ( setting->enum_idx == enum_idx &&
setting->type <= ST_GROUP)
{
const char *short_description = setting->short_description;
if (string_is_empty(short_description))
return NULL;
if (setting->read_handler)
setting->read_handler(setting);
return setting;
}
}
return NULL;
}
int menu_setting_set(unsigned type, unsigned action, bool wraparound)
{
int ret = 0;
struct menu_state *menu_st = menu_state_get_ptr();
menu_list_t *menu_list = menu_st->entries.list;
file_list_t *selection_buf = menu_list ? MENU_LIST_GET_SELECTION(menu_list, 0) : NULL;
size_t selection = menu_st->selection_ptr;
menu_file_list_cbs_t *cbs = selection_buf ?
(menu_file_list_cbs_t*)file_list_get_actiondata_at_offset(selection_buf, selection) : NULL;
if (!cbs)
return 0;
ret = menu_action_handle_setting(cbs->setting,
type, action, wraparound);
if (ret == -1)
return 0;
return ret;
}
/**
* setting_action_start_savestates:
* @data : pointer to setting
*
* Function callback for 'Savestate' action's 'Action Start'
* function pointer.
*
* Returns: 0 on success, -1 on error.
**/
static int setting_action_start_input_device_index(rarch_setting_t *setting)
{
settings_t *settings = config_get_ptr();
if (!setting || !settings)
return -1;
configuration_set_uint(settings,
settings->uints.input_joypad_index[setting->index_offset],
setting->index_offset);
return 0;
}
static int setting_action_start_custom_viewport_width(rarch_setting_t *setting)
{
video_viewport_t vp;
video_driver_state_t *video_st = video_state_get_ptr();
struct retro_system_av_info *av_info = &video_st->av_info;
settings_t *settings = config_get_ptr();
video_viewport_t *custom = &settings->video_viewport_custom;
if (!settings || !av_info)
return -1;
video_driver_get_viewport_info(&vp);
if (settings->bools.video_scale_integer)
{
struct retro_game_geometry *geom = (struct retro_game_geometry*)
&av_info->geometry;
unsigned int rotation = retroarch_get_rotation();
if (rotation % 2)
custom->width = ((custom->width + geom->base_height - 1) /
geom->base_height) * geom->base_height;
else
custom->width = ((custom->width + geom->base_width - 1) /
geom->base_width) * geom->base_width;
}
else
custom->width = vp.full_width - custom->x;
/* aspectratio_lut[ASPECT_RATIO_CUSTOM].value
* is updated in general_write_handler() */
return 0;
}
static int setting_action_start_custom_viewport_height(rarch_setting_t *setting)
{
video_viewport_t vp;
video_driver_state_t *video_st = video_state_get_ptr();
struct retro_system_av_info *av_info = &video_st->av_info;
settings_t *settings = config_get_ptr();
video_viewport_t *custom = &settings->video_viewport_custom;
if (!settings || !av_info)
return -1;
video_driver_get_viewport_info(&vp);
if (settings->bools.video_scale_integer)
{
struct retro_game_geometry *geom = (struct retro_game_geometry*)
&av_info->geometry;
unsigned int rotation = retroarch_get_rotation();
if (rotation % 2)
custom->height = ((custom->height + geom->base_width - 1) /
geom->base_width) * geom->base_width;
else
custom->height = ((custom->height + geom->base_height - 1) /
geom->base_height) * geom->base_height;
}
else
custom->height = vp.full_height - custom->y;
/* aspectratio_lut[ASPECT_RATIO_CUSTOM].value
* is updated in general_write_handler() */
return 0;
}
static int setting_action_start_analog_dpad_mode(rarch_setting_t *setting)
{
if (!setting)
return -1;
*setting->value.target.unsigned_integer = 0;
return 0;
}
static int setting_action_start_libretro_device_type(rarch_setting_t *setting)
{
retro_ctx_controller_info_t pad;
unsigned port = 0;
if (!setting || setting_generic_action_start_default(setting) != 0)
return -1;
port = setting->index_offset;
input_config_set_device(port, RETRO_DEVICE_JOYPAD);
pad.port = port;
pad.device = RETRO_DEVICE_JOYPAD;
core_set_controller_port_device(&pad);
return 0;
}
static int setting_action_start_input_remap_port(rarch_setting_t *setting)
{
unsigned port;
settings_t *settings = config_get_ptr();
struct menu_state *menu_st = menu_state_get_ptr();
if (!setting)
return -1;
port = setting->index_offset;
settings->uints.input_remap_ports[port] = port;
/* Must be called whenever settings->uints.input_remap_ports
* is modified */
input_remapping_update_port_map();
/* Changing mapped port may leave a core port unused;
* reinitialise controllers to ensure that any such
* ports are set to 'RETRO_DEVICE_NONE' */
command_event(CMD_EVENT_CONTROLLER_INIT, NULL);
menu_st->flags |= MENU_ST_FLAG_PREVENT_POPULATE
| MENU_ST_FLAG_ENTRIES_NEED_REFRESH;
return 0;
}
static int setting_action_start_video_refresh_rate_auto(
rarch_setting_t *setting)
{
video_driver_monitor_reset();
return 0;
}
static int setting_action_start_video_refresh_rate_polled(
rarch_setting_t *setting)
{
/* Relay action to ok to prevent duplicate notifications */
return setting_action_ok_video_refresh_rate_polled(setting, 0, false);
}
static int setting_action_start_input_mouse_index(rarch_setting_t *setting)
{
settings_t *settings = config_get_ptr();
if (!setting || !settings)
return -1;
configuration_set_uint(settings,
settings->uints.input_mouse_index[setting->index_offset],
setting->index_offset);
return 0;
}
/**
******* ACTION TOGGLE CALLBACK FUNCTIONS *******
**/
static int setting_action_right_analog_dpad_mode(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
unsigned port = 0;
settings_t *settings = config_get_ptr();
if (!setting)
return -1;
port = setting->index_offset;
settings->modified = true;
settings->uints.input_analog_dpad_mode[port] =
(settings->uints.input_analog_dpad_mode[port] + 1)
% ANALOG_DPAD_LAST;
return 0;
}
static int setting_action_right_libretro_device_type(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
retro_ctx_controller_info_t pad;
unsigned current_device, current_idx, i, devices[128],
types = 0, port = 0;
struct menu_state *menu_st = menu_state_get_ptr();
if (!setting)
return -1;
port = setting->index_offset;
types = libretro_device_get_size(devices, ARRAY_SIZE(devices), port);
current_device = input_config_get_device(port);
current_idx = 0;
for (i = 0; i < types; i++)
{
if (current_device != devices[i])
continue;
current_idx = i;
break;
}
current_device = devices
[(current_idx + 1) % types];
input_config_set_device(port, current_device);
pad.port = port;
pad.device = current_device;
core_set_controller_port_device(&pad);
menu_st->flags |= MENU_ST_FLAG_PREVENT_POPULATE
| MENU_ST_FLAG_ENTRIES_NEED_REFRESH;
return 0;
}
static int setting_action_right_input_remap_port(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
unsigned port = 0;
struct menu_state *menu_st = menu_state_get_ptr();
settings_t *settings = config_get_ptr();
if (!setting)
return -1;
port = setting->index_offset;
if (settings->uints.input_remap_ports[port] < MAX_USERS - 1)
settings->uints.input_remap_ports[port]++;
else
settings->uints.input_remap_ports[port] = 0;
/* Must be called whenever settings->uints.input_remap_ports
* is modified */
input_remapping_update_port_map();
/* Changing mapped port may leave a core port unused;
* reinitialise controllers to ensure that any such
* ports are set to 'RETRO_DEVICE_NONE' */
command_event(CMD_EVENT_CONTROLLER_INIT, NULL);
menu_st->flags |= MENU_ST_FLAG_PREVENT_POPULATE
| MENU_ST_FLAG_ENTRIES_NEED_REFRESH;
return 0;
}
static int setting_action_right_input_device_index(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
settings_t *settings = config_get_ptr();
unsigned *p = NULL;
if (!setting || !settings)
return -1;
p = &settings->uints.input_joypad_index[setting->index_offset];
if (*p < MAX_INPUT_DEVICES - 1)
(*p)++;
else
*p = 0;
settings->modified = true;
return 0;
}
static int setting_action_right_input_mouse_index(
rarch_setting_t *setting, size_t idx, bool wraparound)
{
settings_t *settings = config_get_ptr();
unsigned *p = NULL;
if (!setting || !settings)
return -1;
p = &settings->uints.input_mouse_index[setting->index_offset];
if (*p < MAX_INPUT_DEVICES - 1)
(*p)++;
else
*p = 0;
settings->modified = true;
return 0;
}
/**
******* ACTION OK CALLBACK FUNCTIONS *******
**/
static void
setting_get_string_representation_st_float_video_refresh_rate_polled(
rarch_setting_t *setting, char *s, size_t len)
{
snprintf(s, len, "%.3f Hz", video_driver_get_refresh_rate());
}
static void
setting_get_string_representation_st_float_video_refresh_rate_auto(
rarch_setting_t *setting, char *s, size_t len)
{
double video_refresh_rate = 0.0;
double deviation = 0.0;
unsigned sample_points = 0;
if (!setting)
return;
if (video_monitor_fps_statistics(&video_refresh_rate,
&deviation, &sample_points))
{
gfx_animation_t *p_anim = anim_get_ptr();
snprintf(s, len, "%.3f Hz (%.1f%% dev, %u samples)",
video_refresh_rate, 100.0 * deviation, sample_points);
GFX_ANIMATION_SET_ACTIVE(p_anim);
}
else
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NOT_AVAILABLE), len);
}
#ifdef HAVE_LIBNX
static void get_string_representation_split_joycon(rarch_setting_t *setting, char *s,
size_t len)
{
settings_t *settings = config_get_ptr();
unsigned index_offset = setting->index_offset;
unsigned map = settings->uints.input_split_joycon[index_offset];
if (map == 0)
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF), len);
else
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_ON), len);
}
#endif
static void get_string_representation_input_device_index(
rarch_setting_t *setting, char *s, size_t len)
{
settings_t *settings = config_get_ptr();
unsigned map = 0;
if (!setting || !settings)
return;
map = settings->uints.input_joypad_index[setting->index_offset];
if (map < MAX_INPUT_DEVICES)
{
const char *device_name = input_config_get_device_display_name(map)
? input_config_get_device_display_name(map)
: input_config_get_device_name(map);
if (!string_is_empty(device_name))
{
unsigned idx = input_config_get_device_name_index(map);
size_t _len = strlcpy(s, device_name, len);
/* If idx is non-zero, it's part of a set */
if (idx > 0)
snprintf(s + _len, len - _len, " (%u)", idx);
}
else
snprintf(s, len,
"%s (#%u)",
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NOT_AVAILABLE),
map + 1);
}
if (string_is_empty(s))
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_DISABLED), len);
}
static void get_string_representation_input_mouse_index(
rarch_setting_t *setting, char *s, size_t len)
{
settings_t *settings = config_get_ptr();
unsigned map = 0;
if (!setting || !settings)
return;
map = settings->uints.input_mouse_index[setting->index_offset];
if (map < MAX_INPUT_DEVICES)
{
const char *device_name = input_config_get_mouse_display_name(map);
if (!string_is_empty(device_name))
strlcpy(s, device_name, len);
else if (map > 0)
{
size_t _len = strlcpy(s,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NOT_AVAILABLE),
len);
snprintf(s + _len, len - _len, " (#%u)", map + 1);
}
else
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_DONT_CARE), len);
}
if (string_is_empty(s))
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_DISABLED), len);
}
static void read_handler_audio_rate_control_delta(rarch_setting_t *setting)
{
settings_t *settings = config_get_ptr();
if (!setting || setting->enum_idx == MSG_UNKNOWN)
return;
*setting->value.target.fraction = *(audio_get_float_ptr(AUDIO_ACTION_RATE_CONTROL_DELTA));
if (*setting->value.target.fraction < 0.0005)
{
configuration_set_bool(settings, settings->bools.audio_rate_control, false);
audio_set_float(AUDIO_ACTION_RATE_CONTROL_DELTA, 0.0f);
}
else
{
configuration_set_bool(settings, settings->bools.audio_rate_control, true);
audio_set_float(AUDIO_ACTION_RATE_CONTROL_DELTA, *setting->value.target.fraction);
}
}
static void general_read_handler(rarch_setting_t *setting)
{
settings_t *settings = config_get_ptr();
if (!setting || setting->enum_idx == MSG_UNKNOWN)
return;
switch (setting->enum_idx)
{
case MENU_ENUM_LABEL_AUDIO_MAX_TIMING_SKEW:
*setting->value.target.fraction = settings->floats.audio_max_timing_skew;
break;
case MENU_ENUM_LABEL_VIDEO_REFRESH_RATE_AUTO:
*setting->value.target.fraction = settings->floats.video_refresh_rate;
break;
#ifdef ANDROID
case MENU_ENUM_LABEL_INPUT_SELECT_PHYSICAL_KEYBOARD:
setting->value.target.string = settings->arrays.input_android_physical_keyboard;
break;
#endif
default:
break;
}
}
static enum event_command write_handler_get_cmd(rarch_setting_t *setting)
{
if (setting && setting->cmd_trigger_idx != CMD_EVENT_NONE)
{
uint32_t flags = setting->flags;
if (flags & SD_FLAG_EXIT)
if (*setting->value.target.boolean)
*setting->value.target.boolean = false;
if ( (flags & SD_FLAG_CMD_TRIGGER_EVENT_TRIGGERED)
|| (flags & SD_FLAG_CMD_APPLY_AUTO))
return setting->cmd_trigger_idx;
}
return CMD_EVENT_NONE;
}
static void write_handler_audio_rate_control_delta(rarch_setting_t *setting)
{
settings_t *settings = config_get_ptr();
enum event_command rarch_cmd = CMD_EVENT_NONE;
if (!setting)
return;
rarch_cmd = write_handler_get_cmd(setting);
if (*setting->value.target.fraction < 0.0005)
{
configuration_set_bool(settings, settings->bools.audio_rate_control, false);
audio_set_float(AUDIO_ACTION_RATE_CONTROL_DELTA, 0.0f);
}
else
{
configuration_set_bool(settings, settings->bools.audio_rate_control, true);
audio_set_float(AUDIO_ACTION_RATE_CONTROL_DELTA, *setting->value.target.fraction);
}
if (rarch_cmd || (setting->flags & SD_FLAG_CMD_TRIGGER_EVENT_TRIGGERED))
command_event(rarch_cmd, NULL);
}
static void write_handler_logging_verbosity(rarch_setting_t *setting)
{
enum event_command rarch_cmd = CMD_EVENT_NONE;
if (!setting)
return;
rarch_cmd = write_handler_get_cmd(setting);
if (!verbosity_is_enabled())
{
settings_t *settings = config_get_ptr();
rarch_log_file_init(
settings->bools.log_to_file,
settings->bools.log_to_file_timestamp,
settings->paths.log_dir);
verbosity_enable();
}
else
{
verbosity_disable();
rarch_log_file_deinit();
}
retroarch_override_setting_unset(RARCH_OVERRIDE_SETTING_VERBOSITY, NULL);
if (rarch_cmd || (setting->flags & SD_FLAG_CMD_TRIGGER_EVENT_TRIGGERED))
command_event(rarch_cmd, NULL);
}
static void general_write_handler(rarch_setting_t *setting)
{
enum event_command rarch_cmd = CMD_EVENT_NONE;
settings_t *settings = config_get_ptr();
if (!setting)
return;
rarch_cmd = write_handler_get_cmd(setting);
switch (setting->enum_idx)
{
case MENU_ENUM_LABEL_VIDEO_SHADERS_ENABLE:
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
video_shader_toggle(settings);
#endif
break;
case MENU_ENUM_LABEL_VIDEO_THREADED:
if (*setting->value.target.boolean)
task_queue_set_threaded();
else
task_queue_unset_threaded();
break;
#ifndef HAVE_LAKKA
case MENU_ENUM_LABEL_GAMEMODE_ENABLE:
if (frontend_driver_has_gamemode())
{
bool on = *setting->value.target.boolean;
if (!frontend_driver_set_gamemode(on) && on)
{
/* If we failed to enable game mode, display
* a notification and force disable the feature */
runloop_msg_queue_push(
#ifdef __linux__
msg_hash_to_str(MSG_FAILED_TO_ENTER_GAMEMODE_LINUX),
#else
msg_hash_to_str(MSG_FAILED_TO_ENTER_GAMEMODE),
#endif
1, 180, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
configuration_set_bool(settings,
settings->bools.gamemode_enable, false);
}
}
break;
#endif /*HAVE_LAKKA*/
case MENU_ENUM_LABEL_INPUT_POLL_TYPE_BEHAVIOR:
core_set_poll_type(*setting->value.target.integer);
break;
case MENU_ENUM_LABEL_VIDEO_SCALE_INTEGER:
{
video_viewport_t vp;
video_driver_state_t *video_st = video_state_get_ptr();
struct retro_system_av_info *av_info = &video_st->av_info;
struct video_viewport *custom_vp = &settings->video_viewport_custom;
video_driver_get_viewport_info(&vp);
if (*setting->value.target.boolean)
{
unsigned int rotation = retroarch_get_rotation();
struct retro_game_geometry *geom = (struct retro_game_geometry*)
&av_info->geometry;
custom_vp->x = 0;
custom_vp->y = 0;
if (rotation % 2)
{
custom_vp->width = ((custom_vp->width + geom->base_height - 1) / geom->base_height) * geom->base_height;
custom_vp->height = ((custom_vp->height + geom->base_width - 1) / geom->base_width) * geom->base_width;
}
else
{
custom_vp->width = ((custom_vp->width + geom->base_width - 1) / geom->base_width) * geom->base_width;
custom_vp->height = ((custom_vp->height + geom->base_height - 1) / geom->base_height) * geom->base_height;
}
aspectratio_lut[ASPECT_RATIO_CUSTOM].value =
(float)custom_vp->width / custom_vp->height;
}
}
break;
case MENU_ENUM_LABEL_HELP:
if (*setting->value.target.boolean)
{
menu_displaylist_info_t info;
struct menu_state *menu_st = menu_state_get_ptr();
menu_list_t *menu_list = menu_st->entries.list;
file_list_t *menu_stack = MENU_LIST_GET(menu_list, 0);
menu_displaylist_info_init(&info);
info.enum_idx = MENU_ENUM_LABEL_HELP;
info.label = strdup(
msg_hash_to_str(MENU_ENUM_LABEL_HELP));
info.list = menu_stack;
if (menu_displaylist_ctl(DISPLAYLIST_GENERIC, &info, settings))
menu_displaylist_process(&info);
menu_displaylist_info_free(&info);
*setting->value.target.boolean = false;
if (setting->change_handler)
setting->change_handler(setting);
}
break;
case MENU_ENUM_LABEL_AUDIO_MAX_TIMING_SKEW:
configuration_set_float(settings,
settings->floats.audio_max_timing_skew,
*setting->value.target.fraction);
break;
case MENU_ENUM_LABEL_VIDEO_BLACK_FRAME_INSERTION:
/* If enabling BFI, auto disable other sync settings
that do not work together with BFI */
if (*setting->value.target.unsigned_integer > 0)
{
configuration_set_uint(settings,
settings->uints.video_swap_interval,
0);
configuration_set_uint(settings,
settings->uints.video_frame_delay,
0);
configuration_set_bool(settings,
settings->bools.video_frame_delay_auto,
0);
configuration_set_bool(settings,
settings->bools.vrr_runloop_enable,
0);
configuration_set_uint(settings,
settings->uints.video_shader_subframes,
1);
/* Set reasonable default for dark frames for current BFI value.
Even results OR odd 60hz multiples should be mostly immune to lcd voltage retention.
Nothing to be done for 120hz except phase retention usage if needed. */
if (*setting->value.target.unsigned_integer == 1)
{
configuration_set_uint(settings,
settings->uints.video_bfi_dark_frames,
1);
}
/* Odd 60hz multiples, safe to nudge result over 50% for more clarity by default */
else if ((*setting->value.target.unsigned_integer + 1) % 2 != 0)
{
configuration_set_uint(settings,
settings->uints.video_bfi_dark_frames,
((*setting->value.target.unsigned_integer + 1) / 2) + 1);
}
/* Odd result on even multiple, bump result up one */
else if (((*setting->value.target.unsigned_integer + 1) / 2) % 2 != 0)
{
configuration_set_uint(settings,
settings->uints.video_bfi_dark_frames,
((*setting->value.target.unsigned_integer + 1) / 2) + 1);
}
/* Even result on even multiple, leave alone */
else
{
configuration_set_uint(settings,
settings->uints.video_bfi_dark_frames,
((*setting->value.target.unsigned_integer + 1) / 2));
}
}
#ifdef HAVE_CHEEVOS
rcheevos_validate_config_settings();
#endif
break;
case MENU_ENUM_LABEL_VIDEO_SHADER_SUBFRAMES:
/* If enabling BFI, auto disable other sync settings
that do not work together with subframes */
if (*setting->value.target.unsigned_integer > 1)
{
configuration_set_uint(settings,
settings->uints.video_swap_interval,
0);
configuration_set_uint(settings,
settings->uints.video_frame_delay,
0);
configuration_set_bool(settings,
settings->bools.video_frame_delay_auto,
0);
configuration_set_bool(settings,
settings->bools.vrr_runloop_enable,
0);
configuration_set_uint(settings,
settings->uints.video_black_frame_insertion,
0);
}
#ifdef HAVE_CHEEVOS
rcheevos_validate_config_settings();
#endif
break;
case MENU_ENUM_LABEL_VIDEO_BFI_DARK_FRAMES:
/* Limit choice to max possible for current BFI Hz Setting */
if (*setting->value.target.unsigned_integer > settings->uints.video_black_frame_insertion)
configuration_set_uint(settings,
settings->uints.video_bfi_dark_frames,
settings->uints.video_black_frame_insertion);
break;
case MENU_ENUM_LABEL_VIDEO_FRAME_DELAY:
case MENU_ENUM_LABEL_VIDEO_FRAME_DELAY_AUTO:
case MENU_ENUM_LABEL_VIDEO_SWAP_INTERVAL:
case MENU_ENUM_LABEL_VRR_RUNLOOP_ENABLE:
/* BFI or shader subframes doesn't play nice with any of these */
configuration_set_bool(settings,
settings->uints.video_black_frame_insertion,
0);
configuration_set_uint(settings,
settings->uints.video_shader_subframes,
1);
#ifdef HAVE_CHEEVOS
rcheevos_validate_config_settings();
#endif
break;
case MENU_ENUM_LABEL_VIDEO_REFRESH_RATE_AUTO:
driver_ctl(RARCH_DRIVER_CTL_SET_REFRESH_RATE, setting->value.target.fraction);
/* In case refresh rate update forced non-block video. */
rarch_cmd = CMD_EVENT_VIDEO_SET_BLOCKING_STATE;
break;
case MENU_ENUM_LABEL_VIDEO_REFRESH_RATE_POLLED:
driver_ctl(RARCH_DRIVER_CTL_SET_REFRESH_RATE, setting->value.target.fraction);
/* In case refresh rate update forced non-block video. */
rarch_cmd = CMD_EVENT_VIDEO_SET_BLOCKING_STATE;
break;
#if defined(DINGUX) && defined(DINGUX_BETA)
case MENU_ENUM_LABEL_VIDEO_DINGUX_REFRESH_RATE:
{
enum dingux_refresh_rate
current_refresh_rate = DINGUX_REFRESH_RATE_60HZ;
enum dingux_refresh_rate
target_refresh_rate =
(enum dingux_refresh_rate)settings->uints.video_dingux_refresh_rate;
bool refresh_rate_valid = false;
/* Get current refresh rate */
refresh_rate_valid = dingux_get_video_refresh_rate(&current_refresh_rate);
/* Check if refresh rate has changed */
if (!refresh_rate_valid ||
(current_refresh_rate != target_refresh_rate))
{
/* Get floating point representation of
* new refresh rate */
float hw_refresh_rate = 60.0f;
switch (target_refresh_rate)
{
case DINGUX_REFRESH_RATE_50HZ:
hw_refresh_rate = 50.0f;
default:
break;
}
/* Manually update 'settings->floats.video_refresh_rate'
* (required for correct timing adjustments when
* reinitialising drivers) */
configuration_set_float(settings,
settings->floats.video_refresh_rate,
hw_refresh_rate);
/* Trigger driver reinitialisation */
rarch_cmd = CMD_EVENT_REINIT;
}
}
break;
#endif
case MENU_ENUM_LABEL_VIDEO_SCALE:
settings->modified = true;
settings->uints.video_scale = *setting->value.target.unsigned_integer;
if (!settings->bools.video_fullscreen)
rarch_cmd = CMD_EVENT_REINIT;
break;
case MENU_ENUM_LABEL_VIDEO_HDR_ENABLE:
settings->modified = true;
settings->bools.video_hdr_enable = *setting->value.target.boolean;
rarch_cmd = CMD_EVENT_REINIT;
break;
case MENU_ENUM_LABEL_VIDEO_HDR_MAX_NITS:
{
video_driver_state_t *video_st = video_state_get_ptr();
settings->modified = true;
settings->floats.video_hdr_max_nits = roundf(*setting->value.target.fraction);
if (video_st && video_st->poke && video_st->poke->set_hdr_max_nits)
video_st->poke->set_hdr_max_nits(video_st->data, settings->floats.video_hdr_max_nits);
}
break;
case MENU_ENUM_LABEL_VIDEO_HDR_PAPER_WHITE_NITS:
{
settings_t *settings = config_get_ptr();
video_driver_state_t *video_st = video_state_get_ptr();
settings->modified = true;
settings->floats.video_hdr_paper_white_nits = roundf(*setting->value.target.fraction);
if (video_st && video_st->poke && video_st->poke->set_hdr_paper_white_nits)
video_st->poke->set_hdr_paper_white_nits(video_st->data, settings->floats.video_hdr_paper_white_nits);
}
break;
case MENU_ENUM_LABEL_VIDEO_HDR_CONTRAST:
{
video_driver_state_t *video_st = video_state_get_ptr();
settings->modified = true;
settings->floats.video_hdr_display_contrast = *setting->value.target.fraction;
if (video_st && video_st->poke && video_st->poke->set_hdr_contrast)
video_st->poke->set_hdr_contrast(video_st->data, VIDEO_HDR_MAX_CONTRAST - settings->floats.video_hdr_display_contrast);
}
break;
case MENU_ENUM_LABEL_VIDEO_HDR_EXPAND_GAMUT:
{
video_driver_state_t *video_st = video_state_get_ptr();
settings->modified = true;
settings->bools.video_hdr_expand_gamut = *setting->value.target.boolean;
if (video_st && video_st->poke && video_st->poke->set_hdr_expand_gamut)
video_st->poke->set_hdr_expand_gamut(video_st->data, settings->bools.video_hdr_expand_gamut);
}
break;
case MENU_ENUM_LABEL_INPUT_MAX_USERS:
command_event(CMD_EVENT_CONTROLLER_INIT, NULL);
break;
#ifdef ANDROID
case MENU_ENUM_LABEL_INPUT_SELECT_PHYSICAL_KEYBOARD:
settings->modified = true;
strlcpy(settings->arrays.input_android_physical_keyboard, setting->value.target.string, sizeof(settings->arrays.input_android_physical_keyboard));
break;
#endif
case MENU_ENUM_LABEL_LOG_TO_FILE:
if (verbosity_is_enabled())
{
bool log_to_file = settings->bools.log_to_file;
bool log_to_file_timestamp = settings->bools.log_to_file_timestamp;
const char *log_dir = settings->paths.log_dir;
bool logging_to_file = is_logging_to_file();
if (log_to_file && !logging_to_file)
rarch_log_file_init(
log_to_file,
log_to_file_timestamp,
log_dir);
else if (!log_to_file && logging_to_file)
rarch_log_file_deinit();
}
retroarch_override_setting_unset(RARCH_OVERRIDE_SETTING_LOG_TO_FILE, NULL);
break;
case MENU_ENUM_LABEL_LOG_DIR:
case MENU_ENUM_LABEL_LOG_TO_FILE_TIMESTAMP:
if (verbosity_is_enabled() && is_logging_to_file())
{
bool log_to_file = settings->bools.log_to_file;
bool log_to_file_timestamp = settings->bools.log_to_file_timestamp;
const char *log_dir = settings->paths.log_dir;
rarch_log_file_deinit();
rarch_log_file_init(
log_to_file,
log_to_file_timestamp,
log_dir);
}
break;
case MENU_ENUM_LABEL_VIDEO_SMOOTH:
case MENU_ENUM_LABEL_VIDEO_CTX_SCALING:
#if defined(DINGUX)
case MENU_ENUM_LABEL_VIDEO_DINGUX_IPU_FILTER_TYPE:
#if defined(RS90) || defined(MIYOO)
case MENU_ENUM_LABEL_VIDEO_DINGUX_RS90_SOFTFILTER_TYPE:
#endif
#endif
video_driver_set_filtering(1, settings->bools.video_smooth,
settings->bools.video_ctx_scaling);
break;
case MENU_ENUM_LABEL_VIDEO_ROTATION:
{
video_viewport_t vp;
rarch_system_info_t *sys_info = &runloop_state_get_ptr()->system;
video_driver_state_t *video_st = video_state_get_ptr();
struct retro_system_av_info *av_info = &video_st->av_info;
video_viewport_t *custom_vp = &settings->video_viewport_custom;
if (sys_info)
{
unsigned int rotation = retroarch_get_rotation();
struct retro_game_geometry *geom = (struct retro_game_geometry*)
&av_info->geometry;
video_driver_set_rotation(
(*setting->value.target.unsigned_integer +
sys_info->rotation) % 4);
/* Update Custom Aspect Ratio values */
video_driver_get_viewport_info(&vp);
custom_vp->x = 0;
custom_vp->y = 0;
/* Round down when rotation is "horizontal", round up when rotation is "vertical"
to avoid expanding viewport each time user rotates */
if (rotation % 2)
{
custom_vp->width = MAX(1, (custom_vp->width / geom->base_height)) * geom->base_height;
custom_vp->height = MAX(1, (custom_vp->height / geom->base_width )) * geom->base_width;
}
else
{
custom_vp->width = ((custom_vp->width + geom->base_width - 1) / geom->base_width) * geom->base_width;
custom_vp->height = ((custom_vp->height + geom->base_height - 1) / geom->base_height) * geom->base_height;
}
aspectratio_lut[ASPECT_RATIO_CUSTOM].value = (float)custom_vp->width / custom_vp->height;
/* Update Aspect Ratio (only useful for 1:1 PAR) */
video_driver_set_aspect_ratio();
}
}
break;
case MENU_ENUM_LABEL_SCREEN_ORIENTATION:
#ifndef ANDROID
/* FIXME: Changing at runtime on Android causes setting to somehow be incremented again, many times */
video_display_server_set_screen_orientation(
(enum rotation)(*setting->value.target.unsigned_integer));
#endif
break;
case MENU_ENUM_LABEL_AUDIO_VOLUME:
audio_set_float(AUDIO_ACTION_VOLUME_GAIN, *setting->value.target.fraction);
break;
case MENU_ENUM_LABEL_AUDIO_MIXER_VOLUME:
#ifdef HAVE_AUDIOMIXER
audio_set_float(AUDIO_ACTION_MIXER_VOLUME_GAIN, *setting->value.target.fraction);
#endif
break;
case MENU_ENUM_LABEL_AUDIO_LATENCY:
case MENU_ENUM_LABEL_AUDIO_OUTPUT_RATE:
#ifdef HAVE_WASAPI
case MENU_ENUM_LABEL_AUDIO_WASAPI_EXCLUSIVE_MODE:
case MENU_ENUM_LABEL_AUDIO_WASAPI_FLOAT_FORMAT:
case MENU_ENUM_LABEL_AUDIO_WASAPI_SH_BUFFER_LENGTH:
#endif
rarch_cmd = CMD_EVENT_AUDIO_REINIT;
break;
#ifdef HAVE_MICROPHONE
case MENU_ENUM_LABEL_MICROPHONE_LATENCY:
case MENU_ENUM_LABEL_MICROPHONE_INPUT_RATE:
rarch_cmd = CMD_EVENT_MICROPHONE_REINIT;
break;
#endif
case MENU_ENUM_LABEL_PAL60_ENABLE:
if (*setting->value.target.boolean && global_get_ptr()->console.screen.pal_enable)
rarch_cmd = CMD_EVENT_REINIT;
else
{
*setting->value.target.boolean = false;
if (setting->change_handler)
setting->change_handler(setting);
}
break;
case MENU_ENUM_LABEL_SYSTEM_BGM_ENABLE:
if (*setting->value.target.boolean)
{
#if !defined(__PSL1GHT__) && defined(__PS3__)
cellSysutilEnableBgmPlayback();
#endif
}
else
{
#if !defined(__PSL1GHT__) && defined(__PS3__)
cellSysutilDisableBgmPlayback();
#endif
}
break;
case MENU_ENUM_LABEL_AUDIO_ENABLE_MENU:
#ifdef HAVE_AUDIOMIXER
if (settings->bools.audio_enable_menu)
audio_driver_load_system_sounds();
else
audio_driver_mixer_stop_stream(AUDIO_MIXER_SYSTEM_SLOT_BGM);
#endif
break;
case MENU_ENUM_LABEL_MENU_SOUND_BGM:
#ifdef HAVE_AUDIOMIXER
if (settings->bools.audio_enable_menu)
{
audio_driver_load_system_sounds();
if (settings->bools.audio_enable_menu_bgm)
audio_driver_mixer_play_menu_sound_looped(AUDIO_MIXER_SYSTEM_SLOT_BGM);
else
audio_driver_mixer_stop_stream(AUDIO_MIXER_SYSTEM_SLOT_BGM);
}
#endif
break;
case MENU_ENUM_LABEL_VIDEO_WINDOW_OPACITY:
video_display_server_set_window_opacity(settings->uints.video_window_opacity);
break;
case MENU_ENUM_LABEL_VIDEO_WINDOW_SHOW_DECORATIONS:
video_display_server_set_window_decorations(settings->bools.video_window_show_decorations);
break;
case MENU_ENUM_LABEL_MIDI_INPUT:
midi_driver_set_input(settings->arrays.midi_input);
break;
case MENU_ENUM_LABEL_MIDI_OUTPUT:
midi_driver_set_output(settings, settings->arrays.midi_output);
break;
case MENU_ENUM_LABEL_MIDI_VOLUME:
midi_driver_set_volume(settings->uints.midi_volume);
break;
case MENU_ENUM_LABEL_SUSTAINED_PERFORMANCE_MODE:
frontend_driver_set_sustained_performance_mode(settings->bools.sustained_performance_mode);
break;
case MENU_ENUM_LABEL_REWIND_BUFFER_SIZE_STEP:
{
rarch_setting_t *buffer_size_setting = menu_setting_find_enum(MENU_ENUM_LABEL_REWIND_BUFFER_SIZE);
if (buffer_size_setting)
buffer_size_setting->step = (*setting->value.target.unsigned_integer)*1024*1024;
}
break;
case MENU_ENUM_LABEL_CHEAT_MEMORY_SEARCH_SIZE:
#ifdef HAVE_CHEATS
{
rarch_setting_t *setting = menu_setting_find_enum(MENU_ENUM_LABEL_CHEAT_VALUE);
if (setting)
{
*(setting->value.target.unsigned_integer) = 0;
setting->max = cheat_manager_get_state_search_size(cheat_manager_state.working_cheat.memory_search_size);
}
if ((setting = menu_setting_find_enum(MENU_ENUM_LABEL_CHEAT_RUMBLE_VALUE)))
{
*setting->value.target.unsigned_integer = 0;
setting->max = cheat_manager_get_state_search_size(cheat_manager_state.working_cheat.memory_search_size);
}
if ((setting = menu_setting_find_enum(MENU_ENUM_LABEL_CHEAT_ADDRESS_BIT_POSITION)))
{
int max_bit_position;
*setting->value.target.unsigned_integer = 0;
max_bit_position = cheat_manager_state.working_cheat.memory_search_size<3 ? 255 : 0;
setting->max = max_bit_position;
}
}
#endif
break;
case MENU_ENUM_LABEL_CHEAT_START_OR_RESTART:
#ifdef HAVE_CHEATS
{
rarch_setting_t *setting = menu_setting_find_enum(MENU_ENUM_LABEL_CHEAT_SEARCH_EXACT);
if (setting)
{
*setting->value.target.unsigned_integer = 0;
setting->max = cheat_manager_get_state_search_size(cheat_manager_state.search_bit_size);
}
if ((setting = menu_setting_find_enum(MENU_ENUM_LABEL_CHEAT_SEARCH_EQPLUS)))
{
*setting->value.target.unsigned_integer = 0;
setting->max = cheat_manager_get_state_search_size(cheat_manager_state.search_bit_size);
}
if ((setting = menu_setting_find_enum(MENU_ENUM_LABEL_CHEAT_SEARCH_EQMINUS)))
{
*setting->value.target.unsigned_integer = 0;
setting->max = cheat_manager_get_state_search_size(cheat_manager_state.search_bit_size);
}
}
#endif
break;
case MENU_ENUM_LABEL_CONTENT_FAVORITES_SIZE:
{
unsigned new_capacity = COLLECTION_SIZE;
int content_favorites_size = settings->ints.content_favorites_size;
/* Get new size */
if (content_favorites_size >= 0)
new_capacity = (unsigned)content_favorites_size;
/* Check whether capacity has changed */
if (new_capacity != playlist_capacity(g_defaults.content_favorites))
{
/* Remove excess entries, if required */
while (playlist_size(g_defaults.content_favorites) > new_capacity)
playlist_delete_index(
g_defaults.content_favorites,
playlist_size(g_defaults.content_favorites) - 1);
/* In all cases, need to close and reopen
* playlist file (to update maximum capacity) */
retroarch_favorites_deinit();
retroarch_favorites_init();
#if TARGET_OS_TV
update_topshelf();
#endif
}
}
break;
case MENU_ENUM_LABEL_MANUAL_CONTENT_SCAN_SYSTEM_NAME_CUSTOM:
/* Ensure that custom system name includes no
* invalid characters */
manual_content_scan_scrub_system_name_custom();
break;
case MENU_ENUM_LABEL_MANUAL_CONTENT_SCAN_FILE_EXTS:
/* Ensure that custom file extension list includes
* no period (full stop) characters, and converts
* string to lower case */
manual_content_scan_scrub_file_exts_custom();
break;
case MENU_ENUM_LABEL_MANUAL_CONTENT_SCAN_DAT_FILE:
/* Ensure that DAT file path is valid
* (cannot check file contents here - DAT
* files are too large to load in the UI
* thread - have to wait until the scan task
* is pushed) */
switch (manual_content_scan_validate_dat_file_path())
{
case MANUAL_CONTENT_SCAN_DAT_FILE_INVALID:
runloop_msg_queue_push(
msg_hash_to_str(MSG_MANUAL_CONTENT_SCAN_DAT_FILE_INVALID),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
break;
case MANUAL_CONTENT_SCAN_DAT_FILE_TOO_LARGE:
runloop_msg_queue_push(
msg_hash_to_str(MSG_MANUAL_CONTENT_SCAN_DAT_FILE_TOO_LARGE),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
break;
default:
/* No action required */
break;
}
break;
case MENU_ENUM_LABEL_CHEEVOS_USERNAME:
/* When changing the username, clear out the password and token */
settings->arrays.cheevos_password[0] = '\0';
settings->arrays.cheevos_token[0] = '\0';
break;
case MENU_ENUM_LABEL_CHEEVOS_PASSWORD:
/* When changing the password, clear out the token */
settings->arrays.cheevos_token[0] = '\0';
break;
case MENU_ENUM_LABEL_CHEEVOS_UNLOCK_SOUND_ENABLE:
#ifdef HAVE_AUDIOMIXER
if (settings->bools.cheevos_unlock_sound_enable)
audio_driver_load_system_sounds();
#endif
break;
case MENU_ENUM_LABEL_INPUT_SENSORS_ENABLE:
/* When toggling sensor input off, ensure
* that all sensors are actually disabled */
if (!*setting->value.target.boolean)
{
unsigned i;
for (i = 0; i < DEFAULT_MAX_PADS; i++)
{
/* Event rate does not matter when disabling
* sensors - set to zero */
input_set_sensor_state(i,
RETRO_SENSOR_ACCELEROMETER_DISABLE, 0);
input_set_sensor_state(i,
RETRO_SENSOR_GYROSCOPE_DISABLE, 0);
input_set_sensor_state(i,
RETRO_SENSOR_ILLUMINANCE_DISABLE, 0);
}
}
break;
case MENU_ENUM_LABEL_BRIGHTNESS_CONTROL:
{
frontend_driver_set_screen_brightness(
*setting->value.target.unsigned_integer);
}
break;
case MENU_ENUM_LABEL_INPUT_RUMBLE_GAIN:
{
input_set_rumble_gain(
*setting->value.target.unsigned_integer);
}
break;
case MENU_ENUM_LABEL_WIFI_ENABLED:
#ifdef HAVE_NETWORKING
#ifdef HAVE_WIFI
if (*setting->value.target.boolean)
task_push_wifi_enable(NULL);
else
task_push_wifi_disable(NULL);
#endif
#endif
break;
case MENU_ENUM_LABEL_CORE_INFO_CACHE_ENABLE:
{
const char *dir_libretro = settings->paths.directory_libretro;
const char *path_libretro_info = settings->paths.path_libretro_info;
/* When enabling the core info cache,
* force a cache refresh on the next
* core info initialisation */
if (*setting->value.target.boolean)
if (!core_info_cache_force_refresh(!string_is_empty(path_libretro_info) ?
path_libretro_info : dir_libretro))
{
/* core_info_cache_force_refresh() will fail
* if we cannot write to the the core_info
* directory. This will typically only happen
* on platforms where the core_info directory
* is explicitly (and intentionally) placed on
* read-only storage. In this case, core info
* caching cannot function correctly anyway,
* so we simply force-disable the feature */
configuration_set_bool(settings,
settings->bools.core_info_cache_enable, false);
runloop_msg_queue_push(
msg_hash_to_str(MSG_CORE_INFO_CACHE_UNSUPPORTED),
1, 100, true,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
}
break;
case MENU_ENUM_LABEL_VIDEO_VIEWPORT_CUSTOM_WIDTH:
case MENU_ENUM_LABEL_VIDEO_VIEWPORT_CUSTOM_HEIGHT:
{
/* Whenever custom viewport dimensions are
* changed, ASPECT_RATIO_CUSTOM must be
* recalculated */
video_viewport_t *custom_vp = &settings->video_viewport_custom;
float default_aspect = aspectratio_lut[ASPECT_RATIO_CORE].value;
aspectratio_lut[ASPECT_RATIO_CUSTOM].value =
(custom_vp && custom_vp->width && custom_vp->height) ?
((float)custom_vp->width / (float)custom_vp->height) :
default_aspect;
}
break;
case MENU_ENUM_LABEL_DYNAMIC_WALLPAPER:
{
/* Reset wallpaper by menu context reset */
struct menu_state *menu_st = menu_state_get_ptr();
if (menu_st->driver_ctx && menu_st->driver_ctx->context_reset)
menu_st->driver_ctx->context_reset(menu_st->userdata,
video_driver_is_threaded());
}
break;
default:
/* Special cases */
/* > Mapped Port (virtual -> 'physical' port mapping)
* Occupies a range of enum indices, so cannot
* simply switch on the value */
if ((setting->enum_idx >= MENU_ENUM_LABEL_INPUT_REMAP_PORT) &&
(setting->enum_idx <= MENU_ENUM_LABEL_INPUT_REMAP_PORT_LAST))
{
/* Must be called whenever settings->uints.input_remap_ports
* is modified */
input_remapping_update_port_map();
/* Changing mapped port may leave a core port unused;
* reinitialise controllers to ensure that any such
* ports are set to 'RETRO_DEVICE_NONE' */
command_event(CMD_EVENT_CONTROLLER_INIT, NULL);
}
break;
}
if (rarch_cmd || (setting->flags & SD_FLAG_CMD_TRIGGER_EVENT_TRIGGERED))
command_event(rarch_cmd, NULL);
}
static void frontend_log_level_change_handler(rarch_setting_t *setting)
{
if (!setting)
return;
verbosity_set_log_level(*setting->value.target.unsigned_integer);
}
#ifdef HAVE_RUNAHEAD
static void runahead_change_handler(rarch_setting_t *setting)
{
settings_t *settings = config_get_ptr();
struct menu_state *menu_st = menu_state_get_ptr();
bool run_ahead_enabled = settings->bools.run_ahead_enabled;
bool preempt_enabled = settings->bools.preemptive_frames_enable;
#if (defined(HAVE_DYNAMIC) || defined(HAVE_DYLIB))
unsigned run_ahead_frames = settings->uints.run_ahead_frames;
bool run_ahead_secondary_instance = settings->bools.run_ahead_secondary_instance;
#endif
if (!setting)
return;
switch (setting->enum_idx)
{
case MENU_ENUM_LABEL_RUN_AHEAD_ENABLED:
if (run_ahead_enabled && preempt_enabled)
{
/* Disable preemptive frames and inform user */
settings->bools.preemptive_frames_enable = false;
preempt_deinit(runloop_state_get_ptr());
runloop_msg_queue_push(
msg_hash_to_str(MSG_PREEMPT_DISABLED), 1, 100, false,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
menu_st->flags |= MENU_ST_FLAG_ENTRIES_NEED_REFRESH;
/* fall-through */
case MENU_ENUM_LABEL_RUN_AHEAD_FRAMES:
#if (defined(HAVE_DYNAMIC) || defined(HAVE_DYLIB))
case MENU_ENUM_LABEL_RUN_AHEAD_SECONDARY_INSTANCE:
/* If any changes here will cause second
* instance runahead to be enabled, must
* re-apply cheats to ensure that they
* propagate to the newly-created secondary
* core */
if ( run_ahead_enabled
&& (run_ahead_frames > 0)
&& run_ahead_secondary_instance
&& !retroarch_ctl(RARCH_CTL_IS_SECOND_CORE_LOADED, NULL)
&& retroarch_ctl(RARCH_CTL_IS_SECOND_CORE_AVAILABLE, NULL)
&& command_event(CMD_EVENT_LOAD_SECOND_CORE, NULL))
command_event(CMD_EVENT_CHEATS_APPLY, NULL);
#endif
break;
default:
break;
}
}
static void preempt_change_handler(rarch_setting_t *setting)
{
settings_t *settings = config_get_ptr();
bool preempt_enabled = settings->bools.preemptive_frames_enable;
bool run_ahead_enabled = settings->bools.run_ahead_enabled;
preempt_t *preempt = runloop_state_get_ptr()->preempt_data;
struct menu_state *menu_st = menu_state_get_ptr();
#ifdef HAVE_NETWORKING
bool netplay_enabled = netplay_driver_ctl(RARCH_NETPLAY_CTL_IS_ENABLED, NULL);
#else
bool netplay_enabled = false;
#endif
if (!setting)
return;
switch (setting->enum_idx)
{
case MENU_ENUM_LABEL_PREEMPT_ENABLE:
if (preempt_enabled && run_ahead_enabled)
{
/* Disable runahead and inform user */
settings->bools.run_ahead_enabled = false;
runloop_msg_queue_push(
msg_hash_to_str(MSG_RUNAHEAD_DISABLED), 1, 100, false,
NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
}
if ((preempt_enabled != !!preempt) && !netplay_enabled)
command_event(CMD_EVENT_PREEMPT_UPDATE, NULL);
menu_st->flags |= MENU_ST_FLAG_ENTRIES_NEED_REFRESH;
break;
case MENU_ENUM_LABEL_PREEMPT_FRAMES:
if ( preempt
&& preempt->frames != settings->uints.run_ahead_frames
&& !netplay_enabled)
command_event(CMD_EVENT_PREEMPT_UPDATE, NULL);
break;
default:
break;
}
}
#endif
#ifdef HAVE_OVERLAY
static void overlay_enable_toggle_change_handler(rarch_setting_t *setting)
{
(void)setting;
/* Force a re-init to apply updates */
command_event(CMD_EVENT_OVERLAY_UNLOAD, NULL);
command_event(CMD_EVENT_OVERLAY_INIT, NULL);
}
static void overlay_show_mouse_cursor_change_handler(rarch_setting_t *setting)
{
(void)setting;
input_overlay_check_mouse_cursor();
}
#endif
#ifdef HAVE_CHEEVOS
static void achievement_hardcore_mode_write_handler(rarch_setting_t *setting)
{
rcheevos_hardcore_enabled_changed();
}
static void achievement_leaderboard_trackers_enabled_write_handler(rarch_setting_t* setting)
{
rcheevos_leaderboard_trackers_visibility_changed();
}
static void setting_get_string_representation_uint_cheevos_visibility_summary(
rarch_setting_t* setting,
char* s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case RCHEEVOS_SUMMARY_ALLGAMES:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_CHEEVOS_VISIBILITY_SUMMARY_ALLGAMES),
len);
break;
case RCHEEVOS_SUMMARY_HASCHEEVOS:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_CHEEVOS_VISIBILITY_SUMMARY_HASCHEEVOS),
len);
break;
case RCHEEVOS_SUMMARY_OFF:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_OFF),
len);
break;
}
}
#ifdef HAVE_GFX_WIDGETS
static void setting_get_string_representation_uint_cheevos_appearance_anchor(
rarch_setting_t* setting,
char* s, size_t len)
{
if (!setting)
return;
switch (*setting->value.target.unsigned_integer)
{
case CHEEVOS_APPEARANCE_ANCHOR_TOPLEFT:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_CHEEVOS_APPEARANCE_ANCHOR_TOPLEFT),
len);
break;
case CHEEVOS_APPEARANCE_ANCHOR_TOPCENTER:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_CHEEVOS_APPEARANCE_ANCHOR_TOPCENTER),
len);
break;
case CHEEVOS_APPEARANCE_ANCHOR_TOPRIGHT:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_CHEEVOS_APPEARANCE_ANCHOR_TOPRIGHT),
len);
break;
case CHEEVOS_APPEARANCE_ANCHOR_BOTTOMLEFT:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_CHEEVOS_APPEARANCE_ANCHOR_BOTTOMLEFT),
len);
break;
case CHEEVOS_APPEARANCE_ANCHOR_BOTTOMCENTER:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_CHEEVOS_APPEARANCE_ANCHOR_BOTTOMCENTER),
len);
break;
case CHEEVOS_APPEARANCE_ANCHOR_BOTTOMRIGHT:
strlcpy(s,
msg_hash_to_str(
MENU_ENUM_LABEL_VALUE_CHEEVOS_APPEARANCE_ANCHOR_BOTTOMRIGHT),
len);
break;
}
}
static void cheevos_appearance_write_handler(rarch_setting_t* setting)
{
gfx_widgets_update_cheevos_appearance();
}
#endif
#endif
static void update_streaming_url_write_handler(rarch_setting_t *setting)
{
recording_driver_update_streaming_url();
}
#ifdef HAVE_LAKKA
static void systemd_service_toggle(const char *path, char *unit, bool enable)
{
pid_t pid = fork();
char* args[] = {(char*)"systemctl",
enable ? (char*)"start" : (char*)"stop",
unit,
NULL};
if (pid == 0)
{
if (enable)
filestream_close(filestream_open(path,
RETRO_VFS_FILE_ACCESS_WRITE,
RETRO_VFS_FILE_ACCESS_HINT_NONE));
else
filestream_delete(path);
execvp(args[0], args);
}
}
#ifdef HAVE_LAKKA_SWITCH
static void switch_oc_enable_toggle_change_handler(rarch_setting_t *setting)
{
FILE* f = fopen(SWITCH_OC_TOGGLE_PATH, "w");
if (*setting->value.target.boolean == true) {
fprintf(f, "1\n");
} else {
fprintf(f, "0\n");
}
fclose(f);
}
static void switch_cec_enable_toggle_change_handler(rarch_setting_t *setting)
{
if (*setting->value.target.boolean == true) {
FILE* f = fopen(SWITCH_CEC_TOGGLE_PATH, "w");
fprintf(f, "\n");
fclose(f);
} else {
filestream_delete(SWITCH_CEC_TOGGLE_PATH);
}
}
static void bluetooth_ertm_disable_toggle_change_handler(rarch_setting_t *setting)
{
if (*setting->value.target.boolean == true) {
FILE* f = fopen(BLUETOOTH_ERTM_TOGGLE_PATH, "w");
fprintf(f, "1\n");
fclose(f);
} else {
FILE* f = fopen(BLUETOOTH_ERTM_TOGGLE_PATH, "w");
fprintf(f, "0\n");
fclose(f);
}
}
#endif
static void ssh_enable_toggle_change_handler(rarch_setting_t *setting)
{
systemd_service_toggle(LAKKA_SSH_PATH, (char*)"sshd.service",
*setting->value.target.boolean);
}
static void samba_enable_toggle_change_handler(rarch_setting_t *setting)
{
systemd_service_toggle(LAKKA_SAMBA_PATH, (char*)"smbd.service",
*setting->value.target.boolean);
}
#ifdef HAVE_BLUETOOTH
static void bluetooth_enable_toggle_change_handler(
rarch_setting_t *setting)
{
systemd_service_toggle(LAKKA_BLUETOOTH_PATH,
(char*)"bluetooth.service",
*setting->value.target.boolean);
}
#endif
#ifdef HAVE_WIFI
static void localap_enable_toggle_change_handler(rarch_setting_t *setting)
{
driver_wifi_tether_start_stop(*setting->value.target.boolean,
LAKKA_LOCALAP_PATH);
}
#endif
static void timezone_change_handler(rarch_setting_t *setting)
{
RFILE *tzfp;
if (!setting)
return;
config_set_timezone(setting->value.target.string);
if ((tzfp = filestream_open(LAKKA_TIMEZONE_PATH,
RETRO_VFS_FILE_ACCESS_WRITE,
RETRO_VFS_FILE_ACCESS_HINT_NONE)))
{
filestream_printf(tzfp, "TIMEZONE=%s", setting->value.target.string);
filestream_close(tzfp);
}
}
#endif
static void appicon_change_handler(rarch_setting_t *setting)
{
uico_driver_state_t *uico_st = uico_state_get_ptr();
if (!setting)
return;
if (!uico_st->drv || !uico_st->drv->set_app_icon)
return;
uico_st->drv->set_app_icon(setting->value.target.string);
}
#ifdef _3DS
static void new3ds_speedup_change_handler(rarch_setting_t *setting)
{
if (setting)
osSetSpeedupEnable(*setting->value.target.boolean);
}
#endif
static bool setting_append_list_input_player_options(
rarch_setting_t **list,
rarch_setting_info_t *list_info,
const char *parent_group,
unsigned user)
{
/* This constants matches the string length.
* Keep it up to date or you'll get some really obvious bugs.
* 2 is the length of '99'; we don't need more users than that.
*/
static char buffer[MAX_USERS][13+2+1];
static char group_label[MAX_USERS][255];
unsigned i, j;
rarch_setting_group_info_t group_info;
rarch_setting_group_info_t subgroup_info;
settings_t *settings = config_get_ptr();
rarch_system_info_t *sys_info = &runloop_state_get_ptr()->system;
const struct retro_keybind* const defaults = (user == 0)
? retro_keybinds_1 : retro_keybinds_rest;
const char *temp_value = msg_hash_to_str
((enum msg_hash_enums)(MENU_ENUM_LABEL_INPUT_USER_1_BINDS + user));
group_info.name = NULL;
subgroup_info.name = NULL;
strlcat(buffer[user], "", sizeof(buffer[user]));
strlcpy(group_label[user], temp_value, sizeof(group_label[user]));
START_GROUP(list, list_info, &group_info, group_label[user], parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_SETTINGS);
START_SUB_GROUP(
list,
list_info,
buffer[user],
&group_info,
&subgroup_info,
parent_group);
{
static char device_index[MAX_USERS][64];
static char mouse_index[MAX_USERS][64];
static char analog_to_digital[MAX_USERS][64];
static char bind_all[MAX_USERS][64];
static char bind_all_save_autoconfig[MAX_USERS][64];
static char bind_defaults[MAX_USERS][64];
static char label_device_index[MAX_USERS][64];
static char label_mouse_index[MAX_USERS][64];
static char label_analog_to_digital[MAX_USERS][64];
static char label_bind_all[MAX_USERS][64];
static char label_bind_all_save_autoconfig[MAX_USERS][64];
static char label_bind_defaults[MAX_USERS][64];
#ifdef HAVE_LIBNX
static char split_joycon[MAX_USERS][64];
static char label_split_joycon[MAX_USERS][64];
#endif
snprintf(analog_to_digital[user], sizeof(analog_to_digital[user]),
msg_hash_to_str(MENU_ENUM_LABEL_INPUT_PLAYER_ANALOG_DPAD_MODE), user + 1);
snprintf(device_index[user], sizeof(device_index[user]),
msg_hash_to_str(MENU_ENUM_LABEL_INPUT_JOYPAD_INDEX), user + 1);
snprintf(mouse_index[user], sizeof(mouse_index[user]),
msg_hash_to_str(MENU_ENUM_LABEL_INPUT_MOUSE_INDEX), user + 1);
snprintf(bind_all[user], sizeof(bind_all[user]),
msg_hash_to_str(MENU_ENUM_LABEL_INPUT_BIND_ALL_INDEX), user + 1);
snprintf(bind_all_save_autoconfig[user], sizeof(bind_all_save_autoconfig[user]),
msg_hash_to_str(MENU_ENUM_LABEL_INPUT_SAVE_AUTOCONFIG_INDEX), user + 1);
snprintf(bind_defaults[user], sizeof(bind_defaults[user]),
msg_hash_to_str(MENU_ENUM_LABEL_INPUT_BIND_DEFAULTS_INDEX), user + 1);
strlcpy(label_analog_to_digital[user],
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_INPUT_ADC_TYPE),
sizeof(label_analog_to_digital[user]));
strlcpy(label_device_index[user],
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_INPUT_DEVICE_INDEX),
sizeof(label_device_index[user]));
strlcpy(label_mouse_index[user],
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_INPUT_MOUSE_INDEX),
sizeof(label_mouse_index[user]));
strlcpy(label_bind_all[user],
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_INPUT_BIND_ALL),
sizeof(label_bind_all[user]));
strlcpy(label_bind_defaults[user],
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_INPUT_BIND_DEFAULT_ALL),
sizeof(label_bind_defaults[user]));
strlcpy(label_bind_all_save_autoconfig[user],
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_INPUT_SAVE_AUTOCONFIG),
sizeof(label_bind_all_save_autoconfig[user]));
#ifdef HAVE_LIBNX
snprintf(split_joycon[user], sizeof(split_joycon[user]),
"%s_%u", msg_hash_to_str(MENU_ENUM_LABEL_INPUT_SPLIT_JOYCON), user + 1);
snprintf(label_split_joycon[user], sizeof(label_split_joycon[user]),
"%s %u", msg_hash_to_str(MENU_ENUM_LABEL_VALUE_INPUT_SPLIT_JOYCON), user + 1);
#endif
CONFIG_UINT_ALT(
list, list_info,
&settings->uints.input_analog_dpad_mode[user],
analog_to_digital[user],
label_analog_to_digital[user],
user,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].index = user + 1;
(*list)[list_info->index - 1].index_offset = user;
(*list)[list_info->index - 1].action_left = &setting_action_left_analog_dpad_mode;
(*list)[list_info->index - 1].action_right = &setting_action_right_analog_dpad_mode;
(*list)[list_info->index - 1].action_select = &setting_action_right_analog_dpad_mode;
(*list)[list_info->index - 1].action_start = &setting_action_start_analog_dpad_mode;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_analog_dpad_mode;
menu_settings_list_current_add_range(list, list_info, 0, ANALOG_DPAD_LAST-1, 1.0, true, true);
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_IDX_PTR(list, list_info,
(enum msg_hash_enums)(MENU_ENUM_LABEL_INPUT_PLAYER_ANALOG_DPAD_MODE + user));
#ifdef HAVE_LIBNX
CONFIG_UINT_ALT(
list, list_info,
&settings->uints.input_split_joycon[user],
split_joycon[user],
label_split_joycon[user],
user,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].index = user + 1;
(*list)[list_info->index - 1].index_offset = user;
#if 0
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].action_start = &setting_action_start_input_device_index;
(*list)[list_info->index - 1].action_left = &setting_action_left_input_device_index;
(*list)[list_info->index - 1].action_right = &setting_action_right_input_device_index;
(*list)[list_info->index - 1].action_select = &setting_action_right_input_device_index;
#endif
(*list)[list_info->index - 1].get_string_representation = &get_string_representation_split_joycon;
menu_settings_list_current_add_range(list, list_info, 0, 1, 1.0, true, true);
#endif
CONFIG_UINT_ALT(
list, list_info,
&settings->uints.input_joypad_index[user],
device_index[user],
label_device_index[user],
user,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].index = user + 1;
(*list)[list_info->index - 1].index_offset = user;
(*list)[list_info->index - 1].action_start = &setting_action_start_input_device_index;
(*list)[list_info->index - 1].action_left = &setting_action_left_input_device_index;
(*list)[list_info->index - 1].action_right = &setting_action_right_input_device_index;
(*list)[list_info->index - 1].action_select = &setting_action_right_input_device_index;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&get_string_representation_input_device_index;
menu_settings_list_current_add_range(list, list_info, 0, MAX_INPUT_DEVICES - 1, 1.0, true, true);
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_IDX_PTR(list, list_info,
(enum msg_hash_enums)(MENU_ENUM_LABEL_INPUT_DEVICE_INDEX + user));
CONFIG_UINT_ALT(
list, list_info,
&settings->uints.input_mouse_index[user],
mouse_index[user],
label_mouse_index[user],
user,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].index = user + 1;
(*list)[list_info->index - 1].index_offset = user;
(*list)[list_info->index - 1].action_start = &setting_action_start_input_mouse_index;
(*list)[list_info->index - 1].action_left = &setting_action_left_input_mouse_index;
(*list)[list_info->index - 1].action_right = &setting_action_right_input_mouse_index;
(*list)[list_info->index - 1].action_select = &setting_action_right_input_mouse_index;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&get_string_representation_input_mouse_index;
menu_settings_list_current_add_range(list, list_info, 0, MAX_INPUT_DEVICES - 1, 1.0, true, true);
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_IDX_PTR(list, list_info,
(enum msg_hash_enums)(MENU_ENUM_LABEL_INPUT_MOUSE_INDEX + user));
CONFIG_ACTION_ALT(
list, list_info,
bind_all[user],
label_bind_all[user],
&group_info,
&subgroup_info,
parent_group);
(*list)[list_info->index - 1].index = user + 1;
(*list)[list_info->index - 1].index_offset = user;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_bind_all;
(*list)[list_info->index - 1].action_cancel = NULL;
CONFIG_ACTION_ALT(
list, list_info,
bind_defaults[user],
label_bind_defaults[user],
&group_info,
&subgroup_info,
parent_group);
(*list)[list_info->index - 1].index = user + 1;
(*list)[list_info->index - 1].index_offset = user;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_bind_defaults;
(*list)[list_info->index - 1].action_cancel = NULL;
#ifdef HAVE_CONFIGFILE
CONFIG_ACTION_ALT(
list, list_info,
bind_all_save_autoconfig[user],
label_bind_all_save_autoconfig[user],
&group_info,
&subgroup_info,
parent_group);
(*list)[list_info->index - 1].index = user + 1;
(*list)[list_info->index - 1].index_offset = user;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_bind_all_save_autoconfig;
(*list)[list_info->index - 1].action_cancel = NULL;
#endif
}
{
const char *value_na =
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NOT_AVAILABLE);
for (j = 0; j < RARCH_BIND_LIST_END; j++)
{
char label[NAME_MAX_LENGTH];
char name[NAME_MAX_LENGTH];
size_t _len = 0;
i = (j < RARCH_ANALOG_BIND_LIST_END)
? input_config_bind_order[j]
: j;
if (input_config_bind_map_get_meta(i))
continue;
name[0] = '\0';
if (!string_is_empty(buffer[user]))
{
_len = strlcpy(label, buffer[user], sizeof(label));
label[ _len] = ' ';
label[++_len] = '\0';
}
else
label[0] = '\0';
if (
settings->bools.input_descriptor_label_show
&& (i < RARCH_FIRST_META_KEY)
&& core_has_set_input_descriptor()
&& (i != RARCH_TURBO_ENABLE)
)
{
if (sys_info->input_desc_btn[user][i])
strlcpy(label + _len,
sys_info->input_desc_btn[user][i],
sizeof(label) - _len);
else
{
snprintf(label, sizeof(label), "%s (%s)",
input_config_bind_map_get_desc(i),
value_na);
if (settings->bools.input_descriptor_hide_unbound)
continue;
}
}
else
strlcpy(label + _len,
input_config_bind_map_get_desc(i),
sizeof(label) - _len);
snprintf(name, sizeof(name), "p%u_%s", user + 1, input_config_bind_map_get_base(i));
CONFIG_BIND_ALT(
list, list_info,
&input_config_binds[user][i],
user + 1,
user,
strdup(name),
strdup(label),
&defaults[i],
&group_info,
&subgroup_info,
parent_group);
(*list)[list_info->index - 1].bind_type = i + MENU_SETTINGS_BIND_BEGIN;
}
}
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
return true;
}
static bool setting_append_list_input_libretro_device_options(
rarch_setting_t **list,
rarch_setting_info_t *list_info,
const char *parent_group)
{
rarch_setting_group_info_t group_info;
rarch_setting_group_info_t subgroup_info;
static char key_device_type[MAX_USERS][64];
static char label_device_type[MAX_USERS][64];
unsigned user;
group_info.name = NULL;
subgroup_info.name = NULL;
START_GROUP(list, list_info, &group_info,
"Libretro Device Type", parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info,
&subgroup_info, parent_group);
for (user = 0; user < MAX_USERS; user++)
{
key_device_type[user][0] = '\0';
label_device_type[user][0] = '\0';
snprintf(key_device_type[user], sizeof(key_device_type[user]),
msg_hash_to_str(MENU_ENUM_LABEL_INPUT_LIBRETRO_DEVICE),
user + 1);
strlcpy(label_device_type[user],
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_INPUT_DEVICE_TYPE),
sizeof(label_device_type[user]));
CONFIG_UINT_ALT(
list, list_info,
input_config_get_device_ptr(user),
key_device_type[user],
label_device_type[user],
user,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].index = user + 1;
(*list)[list_info->index - 1].index_offset = user;
(*list)[list_info->index - 1].action_left = &setting_action_left_libretro_device_type;
(*list)[list_info->index - 1].action_right = &setting_action_right_libretro_device_type;
(*list)[list_info->index - 1].action_select = &setting_action_right_libretro_device_type;
(*list)[list_info->index - 1].action_start = &setting_action_start_libretro_device_type;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_libretro_device_type;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_libretro_device;
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_IDX_PTR(list, list_info,
(enum msg_hash_enums)(MENU_ENUM_LABEL_INPUT_LIBRETRO_DEVICE + user));
}
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
return true;
}
static bool setting_append_list_input_remap_port_options(
rarch_setting_t **list,
rarch_setting_info_t *list_info,
const char *parent_group)
{
settings_t *settings = config_get_ptr();
rarch_setting_group_info_t group_info;
rarch_setting_group_info_t subgroup_info;
static char key_port[MAX_USERS][64];
static char label_port[MAX_USERS][64];
unsigned user;
group_info.name = NULL;
subgroup_info.name = NULL;
START_GROUP(list, list_info, &group_info,
"Mapped Ports", parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info,
&subgroup_info, parent_group);
for (user = 0; user < MAX_USERS; user++)
{
key_port[user][0] = '\0';
label_port[user][0] = '\0';
snprintf(key_port[user], sizeof(key_port[user]),
msg_hash_to_str(MENU_ENUM_LABEL_INPUT_REMAP_PORT),
user + 1);
strlcpy(label_port[user],
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_INPUT_REMAP_PORT),
sizeof(label_port[user]));
CONFIG_UINT_ALT(
list, list_info,
&settings->uints.input_remap_ports[user],
key_port[user],
label_port[user],
user,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].index = user + 1;
(*list)[list_info->index - 1].index_offset = user;
(*list)[list_info->index - 1].action_left = &setting_action_left_input_remap_port;
(*list)[list_info->index - 1].action_right = &setting_action_right_input_remap_port;
(*list)[list_info->index - 1].action_select = &setting_action_right_input_remap_port;
(*list)[list_info->index - 1].action_start = &setting_action_start_input_remap_port;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_input_remap_port;
menu_settings_list_current_add_range(list, list_info, 0, MAX_USERS-1, 1.0, true, true);
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_IDX_PTR(list, list_info,
(enum msg_hash_enums)(MENU_ENUM_LABEL_INPUT_REMAP_PORT + user));
}
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
return true;
}
/**
* config_get_audio_resampler_driver_options:
*
* Get an enumerated list of all resampler driver names, separated by '|'.
*
* Returns: string listing of all resampler driver names, separated by '|'.
**/
static const char* config_get_audio_resampler_driver_options(void)
{
return char_list_new_special(STRING_LIST_AUDIO_RESAMPLER_DRIVERS, NULL);
}
static int directory_action_start_generic(rarch_setting_t *setting)
{
if (!setting)
return -1;
if (setting->value.target.string)
strlcpy(setting->value.target.string,
setting->default_value.string,
setting->size);
if (setting->change_handler)
setting->change_handler(setting);
return 0;
}
/**
* config_get_menu_driver_options:
*
* Get an enumerated list of all menu driver names,
* separated by '|'.
*
* Returns: string listing of all menu driver names,
* separated by '|'.
**/
static const char *config_get_menu_driver_options(void)
{
return char_list_new_special(STRING_LIST_MENU_DRIVERS, NULL);
}
static bool setting_append_list(
settings_t *settings,
global_t *global,
enum settings_list_type type,
rarch_setting_t **list,
rarch_setting_info_t *list_info,
const char *parent_group)
{
unsigned user;
rarch_setting_group_info_t group_info;
rarch_setting_group_info_t subgroup_info;
recording_state_t *recording_st = recording_state_get_ptr();
group_info.name = NULL;
subgroup_info.name = NULL;
switch (type)
{
case SETTINGS_LIST_MAIN_MENU:
START_GROUP(list, list_info, &group_info, msg_hash_to_str(MENU_ENUM_LABEL_MAIN_MENU), parent_group);
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_IDX_PTR(list, list_info, MENU_ENUM_LABEL_MAIN_MENU);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
CONFIG_INT(
list, list_info,
&settings->ints.state_slot,
MENU_ENUM_LABEL_STATE_SLOT,
MENU_ENUM_LABEL_VALUE_STATE_SLOT,
0,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].offset_by = -1;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_state_slot;
menu_settings_list_current_add_range(list, list_info, -1, 999, 1, true, true);
#ifdef HAVE_BSV_MOVIE
CONFIG_INT(
list, list_info,
&settings->ints.replay_slot,
MENU_ENUM_LABEL_REPLAY_SLOT,
MENU_ENUM_LABEL_VALUE_REPLAY_SLOT,
0,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].offset_by = -1;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_state_slot;
menu_settings_list_current_add_range(list, list_info, -1, 999, 1, true, true);
#endif
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_START_CORE,
MENU_ENUM_LABEL_VALUE_START_CORE,
&group_info,
&subgroup_info,
parent_group);
#if defined(HAVE_VIDEOPROCESSOR)
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_START_VIDEO_PROCESSOR,
MENU_ENUM_LABEL_VALUE_START_VIDEO_PROCESSOR,
&group_info,
&subgroup_info,
parent_group);
#endif
#if defined(HAVE_NETWORKING) && defined(HAVE_NETWORKGAMEPAD)
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_START_NET_RETROPAD,
MENU_ENUM_LABEL_VALUE_START_NET_RETROPAD,
&group_info,
&subgroup_info,
parent_group);
#endif
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_CONTENT_SETTINGS,
MENU_ENUM_LABEL_VALUE_CONTENT_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_XMB_MAIN_MENU_ENABLE_SETTINGS,
MENU_ENUM_LABEL_VALUE_XMB_MAIN_MENU_ENABLE_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_MENU_DISABLE_KIOSK_MODE,
MENU_ENUM_LABEL_VALUE_MENU_DISABLE_KIOSK_MODE,
&group_info,
&subgroup_info,
parent_group);
#ifndef HAVE_DYNAMIC
if (frontend_driver_has_fork())
#endif
{
char ext_name[16];
if (frontend_driver_get_core_extension(ext_name, sizeof(ext_name)))
{
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_CORE_LIST,
MENU_ENUM_LABEL_VALUE_CORE_LIST,
&group_info,
&subgroup_info,
parent_group);
(*list)[list_info->index - 1].size = (uint32_t)path_get_realsize(RARCH_PATH_CORE);
(*list)[list_info->index - 1].value.target.string = path_get_ptr(RARCH_PATH_CORE);
(*list)[list_info->index - 1].values = ext_name;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_LOAD_CORE);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_BROWSER_ACTION);
}
}
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_LOAD_CONTENT_LIST,
MENU_ENUM_LABEL_VALUE_LOAD_CONTENT_LIST,
&group_info,
&subgroup_info,
parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_SUBSYSTEM_SETTINGS,
MENU_ENUM_LABEL_VALUE_SUBSYSTEM_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
if (settings->bools.history_list_enable)
{
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_LOAD_CONTENT_HISTORY,
MENU_ENUM_LABEL_VALUE_LOAD_CONTENT_HISTORY,
&group_info,
&subgroup_info,
parent_group);
}
#ifdef HAVE_CDROM
/* TODO/FIXME - add check seeing if CDROM is inserted into tray
*/
{
struct string_list *drive_list = cdrom_get_available_drives();
if (drive_list)
{
if (drive_list->size)
{
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_LOAD_DISC,
MENU_ENUM_LABEL_VALUE_LOAD_DISC,
&group_info,
&subgroup_info,
parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_DUMP_DISC,
MENU_ENUM_LABEL_VALUE_DUMP_DISC,
&group_info,
&subgroup_info,
parent_group);
#ifdef HAVE_LAKKA
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_EJECT_DISC,
MENU_ENUM_LABEL_VALUE_EJECT_DISC,
&group_info,
&subgroup_info,
parent_group);
#endif
}
string_list_free(drive_list);
}
}
#endif
if (string_is_not_equal(settings->arrays.menu_driver, "xmb") && string_is_not_equal(settings->arrays.menu_driver, "ozone"))
{
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_ADD_CONTENT_LIST,
MENU_ENUM_LABEL_VALUE_ADD_CONTENT_LIST,
&group_info,
&subgroup_info,
parent_group);
}
#if defined(HAVE_NETWORKING)
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_NETPLAY,
MENU_ENUM_LABEL_VALUE_NETPLAY,
&group_info,
&subgroup_info,
parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_ONLINE_UPDATER,
MENU_ENUM_LABEL_VALUE_ONLINE_UPDATER,
&group_info,
&subgroup_info,
parent_group);
#endif
#ifdef HAVE_MIST
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_CORE_MANAGER_STEAM_LIST,
MENU_ENUM_LABEL_VALUE_CORE_MANAGER_STEAM_LIST,
&group_info,
&subgroup_info,
parent_group);
#endif
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_SETTINGS,
MENU_ENUM_LABEL_VALUE_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_INFORMATION_LIST,
MENU_ENUM_LABEL_VALUE_INFORMATION_LIST,
&group_info,
&subgroup_info,
parent_group);
#if !defined(IOS) && !defined(HAVE_LAKKA)
if (frontend_driver_has_fork())
{
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_RESTART_RETROARCH,
MENU_ENUM_LABEL_VALUE_RESTART_RETROARCH,
&group_info,
&subgroup_info,
parent_group);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_RESTART_RETROARCH);
}
#endif
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_CONFIGURATIONS_LIST,
MENU_ENUM_LABEL_VALUE_CONFIGURATIONS_LIST,
&group_info,
&subgroup_info,
parent_group);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_CONFIGURATIONS,
MENU_ENUM_LABEL_VALUE_CONFIGURATIONS,
&group_info,
&subgroup_info,
parent_group);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_SAVE_CURRENT_CONFIG,
MENU_ENUM_LABEL_VALUE_SAVE_CURRENT_CONFIG,
&group_info,
&subgroup_info,
parent_group);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_MENU_SAVE_CURRENT_CONFIG);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_SAVE_NEW_CONFIG,
MENU_ENUM_LABEL_VALUE_SAVE_NEW_CONFIG,
&group_info,
&subgroup_info,
parent_group);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_MENU_SAVE_CONFIG);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_RESET_TO_DEFAULT_CONFIG,
MENU_ENUM_LABEL_VALUE_RESET_TO_DEFAULT_CONFIG,
&group_info,
&subgroup_info,
parent_group);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_MENU_RESET_TO_DEFAULT_CONFIG);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_SAVE_CURRENT_CONFIG_OVERRIDE_CORE,
MENU_ENUM_LABEL_VALUE_SAVE_CURRENT_CONFIG_OVERRIDE_CORE,
&group_info,
&subgroup_info,
parent_group);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_MENU_SAVE_CURRENT_CONFIG_OVERRIDE_CORE);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_SAVE_CURRENT_CONFIG_OVERRIDE_CONTENT_DIR,
MENU_ENUM_LABEL_VALUE_SAVE_CURRENT_CONFIG_OVERRIDE_CONTENT_DIR,
&group_info,
&subgroup_info,
parent_group);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_MENU_SAVE_CURRENT_CONFIG_OVERRIDE_CONTENT_DIR);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_SAVE_CURRENT_CONFIG_OVERRIDE_GAME,
MENU_ENUM_LABEL_VALUE_SAVE_CURRENT_CONFIG_OVERRIDE_GAME,
&group_info,
&subgroup_info,
parent_group);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_MENU_SAVE_CURRENT_CONFIG_OVERRIDE_GAME);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_REMOVE_CURRENT_CONFIG_OVERRIDE_CORE,
MENU_ENUM_LABEL_VALUE_REMOVE_CURRENT_CONFIG_OVERRIDE_CORE,
&group_info,
&subgroup_info,
parent_group);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_MENU_REMOVE_CURRENT_CONFIG_OVERRIDE_CORE);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_REMOVE_CURRENT_CONFIG_OVERRIDE_CONTENT_DIR,
MENU_ENUM_LABEL_VALUE_REMOVE_CURRENT_CONFIG_OVERRIDE_CONTENT_DIR,
&group_info,
&subgroup_info,
parent_group);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_MENU_REMOVE_CURRENT_CONFIG_OVERRIDE_CONTENT_DIR);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_REMOVE_CURRENT_CONFIG_OVERRIDE_GAME,
MENU_ENUM_LABEL_VALUE_REMOVE_CURRENT_CONFIG_OVERRIDE_GAME,
&group_info,
&subgroup_info,
parent_group);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_MENU_REMOVE_CURRENT_CONFIG_OVERRIDE_GAME);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_HELP_LIST,
MENU_ENUM_LABEL_VALUE_HELP_LIST,
&group_info,
&subgroup_info,
parent_group);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
#ifdef HAVE_QT
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_SHOW_WIMP,
MENU_ENUM_LABEL_VALUE_SHOW_WIMP,
&group_info,
&subgroup_info,
parent_group);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_UI_COMPANION_TOGGLE);
#endif
#if !defined(IOS)
/* Apple rejects iOS apps that let you forcibly quit them. */
#ifdef HAVE_LAKKA
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_QUIT_RETROARCH,
MENU_ENUM_LABEL_VALUE_RESTART_RETROARCH,
&group_info,
&subgroup_info,
parent_group);
#else
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_QUIT_RETROARCH,
MENU_ENUM_LABEL_VALUE_QUIT_RETROARCH,
&group_info,
&subgroup_info,
parent_group);
#endif
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_QUIT);
#endif
#ifdef HAVE_LIBNX
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_SWITCH_CPU_PROFILE,
MENU_ENUM_LABEL_VALUE_SWITCH_CPU_PROFILE,
&group_info,
&subgroup_info,
parent_group);
#endif
#if defined(HAVE_LAKKA)
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_REBOOT,
MENU_ENUM_LABEL_VALUE_REBOOT,
&group_info,
&subgroup_info,
parent_group);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_REBOOT);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_SHUTDOWN,
MENU_ENUM_LABEL_VALUE_SHUTDOWN,
&group_info,
&subgroup_info,
parent_group);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_SHUTDOWN);
#endif
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_DRIVER_SETTINGS,
MENU_ENUM_LABEL_VALUE_DRIVER_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_VIDEO_SETTINGS,
MENU_ENUM_LABEL_VALUE_VIDEO_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_CRT_SWITCHRES_SETTINGS,
MENU_ENUM_LABEL_VALUE_CRT_SWITCHRES_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_VIDEO_OUTPUT_SETTINGS,
MENU_ENUM_LABEL_VALUE_VIDEO_OUTPUT_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_AUDIO_SETTINGS,
MENU_ENUM_LABEL_VALUE_AUDIO_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
#ifdef HAVE_AUDIOMIXER
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_AUDIO_MIXER_SETTINGS,
MENU_ENUM_LABEL_VALUE_AUDIO_MIXER_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
#endif
#ifdef HAVE_AUDIOMIXER
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_MENU_SOUNDS,
MENU_ENUM_LABEL_VALUE_MENU_SOUNDS,
&group_info,
&subgroup_info,
parent_group);
#endif
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_INPUT_SETTINGS,
MENU_ENUM_LABEL_VALUE_INPUT_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_LATENCY_SETTINGS,
MENU_ENUM_LABEL_VALUE_LATENCY_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_CORE_SETTINGS,
MENU_ENUM_LABEL_VALUE_CORE_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_CONFIGURATION_SETTINGS,
MENU_ENUM_LABEL_VALUE_CONFIGURATION_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_SAVING_SETTINGS,
MENU_ENUM_LABEL_VALUE_SAVING_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_LOGGING_SETTINGS,
MENU_ENUM_LABEL_VALUE_LOGGING_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_FRAME_THROTTLE_SETTINGS,
MENU_ENUM_LABEL_VALUE_FRAME_THROTTLE_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_REWIND_SETTINGS,
MENU_ENUM_LABEL_VALUE_REWIND_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_FRAME_TIME_COUNTER_SETTINGS,
MENU_ENUM_LABEL_VALUE_FRAME_TIME_COUNTER_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_CHEAT_DETAILS_SETTINGS,
MENU_ENUM_LABEL_VALUE_CHEAT_DETAILS_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_CHEAT_SEARCH_SETTINGS,
MENU_ENUM_LABEL_VALUE_CHEAT_SEARCH_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
if (string_is_not_equal(settings->arrays.record_driver, "null"))
{
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_RECORDING_SETTINGS,
MENU_ENUM_LABEL_VALUE_RECORDING_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
}
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_ONSCREEN_DISPLAY_SETTINGS,
MENU_ENUM_LABEL_VALUE_ONSCREEN_DISPLAY_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
#ifdef HAVE_OVERLAY
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_ONSCREEN_OVERLAY_SETTINGS,
MENU_ENUM_LABEL_VALUE_ONSCREEN_OVERLAY_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_OVERLAY_LIGHTGUN_SETTINGS,
MENU_ENUM_LABEL_VALUE_OVERLAY_LIGHTGUN_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_OVERLAY_MOUSE_SETTINGS,
MENU_ENUM_LABEL_VALUE_OVERLAY_MOUSE_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_OSK_OVERLAY_SETTINGS,
MENU_ENUM_LABEL_VALUE_OSK_OVERLAY_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
#endif
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_ONSCREEN_NOTIFICATIONS_SETTINGS,
MENU_ENUM_LABEL_VALUE_ONSCREEN_NOTIFICATIONS_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_ONSCREEN_NOTIFICATIONS_VIEWS_SETTINGS,
MENU_ENUM_LABEL_VALUE_ONSCREEN_NOTIFICATIONS_VIEWS_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_MENU_SETTINGS,
MENU_ENUM_LABEL_VALUE_MENU_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
#ifdef _3DS
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_MENU_BOTTOM_SETTINGS,
MENU_ENUM_LABEL_VALUE_MENU_BOTTOM_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
#endif
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_MENU_VIEWS_SETTINGS,
MENU_ENUM_LABEL_VALUE_MENU_VIEWS_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_QUICK_MENU_VIEWS_SETTINGS,
MENU_ENUM_LABEL_VALUE_QUICK_MENU_VIEWS_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_SETTINGS_VIEWS_SETTINGS,
MENU_ENUM_LABEL_VALUE_SETTINGS_VIEWS_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_USER_INTERFACE_SETTINGS,
MENU_ENUM_LABEL_VALUE_USER_INTERFACE_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_AI_SERVICE_SETTINGS,
MENU_ENUM_LABEL_VALUE_AI_SERVICE_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
#ifdef HAVE_ACCESSIBILITY
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_ACCESSIBILITY_SETTINGS,
MENU_ENUM_LABEL_VALUE_ACCESSIBILITY_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
#endif
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_POWER_MANAGEMENT_SETTINGS,
MENU_ENUM_LABEL_VALUE_POWER_MANAGEMENT_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_MENU_FILE_BROWSER_SETTINGS,
MENU_ENUM_LABEL_VALUE_MENU_FILE_BROWSER_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
#ifdef HAVE_CHEEVOS
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_RETRO_ACHIEVEMENTS_SETTINGS,
MENU_ENUM_LABEL_VALUE_RETRO_ACHIEVEMENTS_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_CHEEVOS_APPEARANCE_SETTINGS,
MENU_ENUM_LABEL_VALUE_CHEEVOS_APPEARANCE_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_CHEEVOS_VISIBILITY_SETTINGS,
MENU_ENUM_LABEL_VALUE_CHEEVOS_VISIBILITY_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
#endif
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_UPDATER_SETTINGS,
MENU_ENUM_LABEL_VALUE_UPDATER_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
#ifdef HAVE_LAKKA
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
#endif
#ifdef HAVE_BLUETOOTH
if (string_is_not_equal(
settings->arrays.bluetooth_driver, "null"))
{
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_BLUETOOTH_SETTINGS,
MENU_ENUM_LABEL_VALUE_BLUETOOTH_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
}
#endif
#if defined(HAVE_LAKKA) || defined(HAVE_WIFI)
if (string_is_not_equal(settings->arrays.wifi_driver, "null"))
{
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_WIFI_SETTINGS,
MENU_ENUM_LABEL_VALUE_WIFI_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
}
#endif
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_NETWORK_SETTINGS,
MENU_ENUM_LABEL_VALUE_NETWORK_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
#ifdef HAVE_LAKKA
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_LAKKA_SERVICES,
MENU_ENUM_LABEL_VALUE_LAKKA_SERVICES,
&group_info,
&subgroup_info,
parent_group);
#endif
#ifdef HAVE_LAKKA_SWITCH
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_LAKKA_SWITCH_OPTIONS,
MENU_ENUM_LABEL_VALUE_LAKKA_SWITCH_OPTIONS,
&group_info,
&subgroup_info,
parent_group);
#endif
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_PLAYLIST_SETTINGS,
MENU_ENUM_LABEL_VALUE_PLAYLIST_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_USER_SETTINGS,
MENU_ENUM_LABEL_VALUE_USER_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_DIRECTORY_SETTINGS,
MENU_ENUM_LABEL_VALUE_DIRECTORY_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_PRIVACY_SETTINGS,
MENU_ENUM_LABEL_VALUE_PRIVACY_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_AUDIO_OUTPUT_SETTINGS,
MENU_ENUM_LABEL_VALUE_AUDIO_OUTPUT_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
#ifdef HAVE_MICROPHONE
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_MICROPHONE_SETTINGS,
MENU_ENUM_LABEL_VALUE_MICROPHONE_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
#endif
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_AUDIO_SYNCHRONIZATION_SETTINGS,
MENU_ENUM_LABEL_VALUE_AUDIO_SYNCHRONIZATION_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
#ifdef HAVE_MIST
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_STEAM_SETTINGS,
MENU_ENUM_LABEL_VALUE_STEAM_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
#endif
if (string_is_not_equal(settings->arrays.midi_driver, "null"))
{
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_MIDI_SETTINGS,
MENU_ENUM_LABEL_VALUE_MIDI_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
}
for (user = 0; user < MAX_USERS; user++)
setting_append_list_input_player_options(list, list_info, parent_group, user);
setting_append_list_input_libretro_device_options(list, list_info, parent_group);
setting_append_list_input_remap_port_options(list, list_info, parent_group);
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
case SETTINGS_LIST_DRIVERS:
{
unsigned i, j = 0;
struct string_options_entry string_options_entries[14] = {{0}};
START_GROUP(list, list_info, &group_info, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_DRIVER_SETTINGS), parent_group);
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_IDX_PTR(list, list_info, MENU_ENUM_LABEL_DRIVER_SETTINGS);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info,
&subgroup_info, parent_group);
string_options_entries[j].target = settings->arrays.input_driver;
string_options_entries[j].len = sizeof(settings->arrays.input_driver);
string_options_entries[j].name_enum_idx = MENU_ENUM_LABEL_INPUT_DRIVER;
string_options_entries[j].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_INPUT_DRIVER;
string_options_entries[j].default_value = config_get_default_input();
string_options_entries[j].values = config_get_input_driver_options();
j++;
string_options_entries[j].target = settings->arrays.input_joypad_driver;
string_options_entries[j].len = sizeof(settings->arrays.input_joypad_driver);
string_options_entries[j].name_enum_idx = MENU_ENUM_LABEL_JOYPAD_DRIVER;
string_options_entries[j].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_JOYPAD_DRIVER;
string_options_entries[j].default_value = config_get_default_joypad();
string_options_entries[j].values = config_get_joypad_driver_options();
j++;
string_options_entries[j].target = settings->arrays.video_driver;
string_options_entries[j].len = sizeof(settings->arrays.video_driver);
string_options_entries[j].name_enum_idx = MENU_ENUM_LABEL_VIDEO_DRIVER;
string_options_entries[j].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_VIDEO_DRIVER;
string_options_entries[j].default_value = config_get_default_video();
string_options_entries[j].values = config_get_video_driver_options();
j++;
string_options_entries[j].target = settings->arrays.audio_driver;
string_options_entries[j].len = sizeof(settings->arrays.audio_driver);
string_options_entries[j].name_enum_idx = MENU_ENUM_LABEL_AUDIO_DRIVER;
string_options_entries[j].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_AUDIO_DRIVER;
string_options_entries[j].default_value = config_get_default_audio();
string_options_entries[j].values = config_get_audio_driver_options();
j++;
#ifdef HAVE_MICROPHONE
string_options_entries[j].target = settings->arrays.microphone_driver;
string_options_entries[j].len = sizeof(settings->arrays.microphone_driver);
string_options_entries[j].name_enum_idx = MENU_ENUM_LABEL_MICROPHONE_DRIVER;
string_options_entries[j].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_MICROPHONE_DRIVER;
string_options_entries[j].default_value = config_get_default_microphone();
string_options_entries[j].values = config_get_microphone_driver_options();
j++;
#endif
string_options_entries[j].target = settings->arrays.audio_resampler;
string_options_entries[j].len = sizeof(settings->arrays.audio_resampler);
string_options_entries[j].name_enum_idx = MENU_ENUM_LABEL_AUDIO_RESAMPLER_DRIVER;
string_options_entries[j].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_AUDIO_RESAMPLER_DRIVER;
string_options_entries[j].default_value = config_get_default_audio_resampler();
string_options_entries[j].values = config_get_audio_resampler_driver_options();
j++;
#ifdef HAVE_MICROPHONE
string_options_entries[j].target = settings->arrays.microphone_resampler;
string_options_entries[j].len = sizeof(settings->arrays.microphone_resampler);
string_options_entries[j].name_enum_idx = MENU_ENUM_LABEL_MICROPHONE_RESAMPLER_DRIVER;
string_options_entries[j].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_MICROPHONE_RESAMPLER_DRIVER;
string_options_entries[j].default_value = config_get_default_audio_resampler();
string_options_entries[j].values = config_get_audio_resampler_driver_options();
j++;
#endif
string_options_entries[j].target = settings->arrays.camera_driver;
string_options_entries[j].len = sizeof(settings->arrays.camera_driver);
string_options_entries[j].name_enum_idx = MENU_ENUM_LABEL_CAMERA_DRIVER;
string_options_entries[j].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_CAMERA_DRIVER;
string_options_entries[j].default_value = config_get_default_camera();
string_options_entries[j].values = config_get_camera_driver_options();
j++;
#ifdef HAVE_BLUETOOTH
string_options_entries[j].target = settings->arrays.bluetooth_driver;
string_options_entries[j].len = sizeof(settings->arrays.bluetooth_driver);
string_options_entries[j].name_enum_idx = MENU_ENUM_LABEL_BLUETOOTH_DRIVER;
string_options_entries[j].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_BLUETOOTH_DRIVER;
string_options_entries[j].default_value = config_get_default_bluetooth();
string_options_entries[j].values = config_get_bluetooth_driver_options();
j++;
#endif
#ifdef HAVE_WIFI
string_options_entries[j].target = settings->arrays.wifi_driver;
string_options_entries[j].len = sizeof(settings->arrays.wifi_driver);
string_options_entries[j].name_enum_idx = MENU_ENUM_LABEL_WIFI_DRIVER;
string_options_entries[j].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_WIFI_DRIVER;
string_options_entries[j].default_value = config_get_default_wifi();
string_options_entries[j].values = config_get_wifi_driver_options();
j++;
#endif
string_options_entries[j].target = settings->arrays.location_driver;
string_options_entries[j].len = sizeof(settings->arrays.location_driver);
string_options_entries[j].name_enum_idx = MENU_ENUM_LABEL_LOCATION_DRIVER;
string_options_entries[j].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_LOCATION_DRIVER;
string_options_entries[j].default_value = config_get_default_location();
string_options_entries[j].values = config_get_location_driver_options();
j++;
string_options_entries[j].target = settings->arrays.menu_driver;
string_options_entries[j].len = sizeof(settings->arrays.menu_driver);
string_options_entries[j].name_enum_idx = MENU_ENUM_LABEL_MENU_DRIVER;
string_options_entries[j].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_MENU_DRIVER;
string_options_entries[j].default_value = config_get_default_menu();
string_options_entries[j].values = config_get_menu_driver_options();
j++;
string_options_entries[j].target = settings->arrays.record_driver;
string_options_entries[j].len = sizeof(settings->arrays.record_driver);
string_options_entries[j].name_enum_idx = MENU_ENUM_LABEL_RECORD_DRIVER;
string_options_entries[j].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_RECORD_DRIVER;
string_options_entries[j].default_value = config_get_default_record();
string_options_entries[j].values = config_get_record_driver_options();
j++;
string_options_entries[j].target = settings->arrays.midi_driver;
string_options_entries[j].len = sizeof(settings->arrays.midi_driver);
string_options_entries[j].name_enum_idx = MENU_ENUM_LABEL_MIDI_DRIVER;
string_options_entries[j].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_MIDI_DRIVER;
string_options_entries[j].default_value = config_get_default_midi();
string_options_entries[j].values = config_get_midi_driver_options();
j++;
for (i = 0; i < j; i++)
{
CONFIG_STRING_OPTIONS(
list, list_info,
string_options_entries[i].target,
string_options_entries[i].len,
string_options_entries[i].name_enum_idx,
string_options_entries[i].SHORT_enum_idx,
string_options_entries[i].default_value,
string_options_entries[i].values,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_IS_DRIVER);
(*list)[list_info->index - 1].action_ok = setting_action_ok_uint;
(*list)[list_info->index - 1].action_left = setting_string_action_left_driver;
(*list)[list_info->index - 1].action_right = setting_string_action_right_driver;
}
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
}
break;
case SETTINGS_LIST_CORE:
{
unsigned i, listing = 0;
#ifndef HAVE_DYNAMIC
struct bool_entry bool_entries[11];
#else
struct bool_entry bool_entries[10];
#endif
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_CORE_SETTINGS), parent_group);
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_IDX_PTR(list, list_info, MENU_ENUM_LABEL_CORE_SETTINGS);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info,
parent_group);
bool_entries[listing].target = &settings->bools.video_shared_context;
bool_entries[listing].name_enum_idx = MENU_ENUM_LABEL_VIDEO_SHARED_CONTEXT;
bool_entries[listing].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_VIDEO_SHARED_CONTEXT;
bool_entries[listing].default_value = DEFAULT_VIDEO_SHARED_CONTEXT;
bool_entries[listing].flags = SD_FLAG_ADVANCED;
listing++;
bool_entries[listing].target = &settings->bools.driver_switch_enable;
bool_entries[listing].name_enum_idx = MENU_ENUM_LABEL_DRIVER_SWITCH_ENABLE;
bool_entries[listing].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_DRIVER_SWITCH_ENABLE;
bool_entries[listing].default_value = DEFAULT_DRIVER_SWITCH_ENABLE;
bool_entries[listing].flags = SD_FLAG_ADVANCED;
listing++;
bool_entries[listing].target = &settings->bools.load_dummy_on_core_shutdown;
bool_entries[listing].name_enum_idx = MENU_ENUM_LABEL_DUMMY_ON_CORE_SHUTDOWN;
bool_entries[listing].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_DUMMY_ON_CORE_SHUTDOWN;
bool_entries[listing].default_value = DEFAULT_LOAD_DUMMY_ON_CORE_SHUTDOWN;
bool_entries[listing].flags = SD_FLAG_ADVANCED;
listing++;
bool_entries[listing].target = &settings->bools.set_supports_no_game_enable;
bool_entries[listing].name_enum_idx = MENU_ENUM_LABEL_CORE_SET_SUPPORTS_NO_CONTENT_ENABLE;
bool_entries[listing].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_CORE_SET_SUPPORTS_NO_CONTENT_ENABLE;
bool_entries[listing].default_value = true;
bool_entries[listing].flags = SD_FLAG_ADVANCED;
listing++;
bool_entries[listing].target = &settings->bools.check_firmware_before_loading;
bool_entries[listing].name_enum_idx = MENU_ENUM_LABEL_CHECK_FOR_MISSING_FIRMWARE;
bool_entries[listing].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_CHECK_FOR_MISSING_FIRMWARE;
bool_entries[listing].default_value = DEFAULT_CHECK_FIRMWARE_BEFORE_LOADING;
bool_entries[listing].flags = SD_FLAG_ADVANCED;
listing++;
bool_entries[listing].target = &settings->bools.systemfiles_in_content_dir;
bool_entries[listing].name_enum_idx = MENU_ENUM_LABEL_SYSTEMFILES_IN_CONTENT_DIR_ENABLE;
bool_entries[listing].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_SYSTEMFILES_IN_CONTENT_DIR_ENABLE;
bool_entries[listing].default_value = DEFAULT_SYSTEMFILES_IN_CONTENT_DIR;
bool_entries[listing].flags = SD_FLAG_ADVANCED;
listing++;
bool_entries[listing].target = &settings->bools.video_allow_rotate;
bool_entries[listing].name_enum_idx = MENU_ENUM_LABEL_VIDEO_ALLOW_ROTATE;
bool_entries[listing].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_VIDEO_ALLOW_ROTATE;
bool_entries[listing].default_value = DEFAULT_ALLOW_ROTATE;
bool_entries[listing].flags = SD_FLAG_ADVANCED;
listing++;
bool_entries[listing].target = &settings->bools.core_option_category_enable;
bool_entries[listing].name_enum_idx = MENU_ENUM_LABEL_CORE_OPTION_CATEGORY_ENABLE;
bool_entries[listing].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_CORE_OPTION_CATEGORY_ENABLE;
bool_entries[listing].default_value = DEFAULT_CORE_OPTION_CATEGORY_ENABLE;
bool_entries[listing].flags = SD_FLAG_NONE;
listing++;
bool_entries[listing].target = &settings->bools.core_info_cache_enable;
bool_entries[listing].name_enum_idx = MENU_ENUM_LABEL_CORE_INFO_CACHE_ENABLE;
bool_entries[listing].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_CORE_INFO_CACHE_ENABLE;
bool_entries[listing].default_value = DEFAULT_CORE_INFO_CACHE_ENABLE;
bool_entries[listing].flags = SD_FLAG_ADVANCED;
listing++;
bool_entries[listing].target = &settings->bools.core_info_savestate_bypass;
bool_entries[listing].name_enum_idx = MENU_ENUM_LABEL_CORE_INFO_SAVESTATE_BYPASS;
bool_entries[listing].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_CORE_INFO_SAVESTATE_BYPASS;
bool_entries[listing].default_value = DEFAULT_CORE_INFO_SAVESTATE_BYPASS;
bool_entries[listing].flags = SD_FLAG_ADVANCED;
listing++;
#ifndef HAVE_DYNAMIC
bool_entries[listing].target = &settings->bools.always_reload_core_on_run_content;
bool_entries[listing].name_enum_idx = MENU_ENUM_LABEL_ALWAYS_RELOAD_CORE_ON_RUN_CONTENT;
bool_entries[listing].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_ALWAYS_RELOAD_CORE_ON_RUN_CONTENT;
bool_entries[listing].default_value = DEFAULT_ALWAYS_RELOAD_CORE_ON_RUN_CONTENT;
bool_entries[listing].flags = SD_FLAG_ADVANCED;
listing++;
#endif
for (i = 0; i < ARRAY_SIZE(bool_entries); i++)
{
#if !defined(HAVE_CORE_INFO_CACHE)
if (bool_entries[i].name_enum_idx ==
MENU_ENUM_LABEL_CORE_INFO_CACHE_ENABLE)
continue;
#endif
CONFIG_BOOL(
list, list_info,
bool_entries[i].target,
bool_entries[i].name_enum_idx,
bool_entries[i].SHORT_enum_idx,
bool_entries[i].default_value,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
bool_entries[i].flags);
}
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
}
break;
case SETTINGS_LIST_CONFIGURATION:
{
uint8_t i, listing = 0;
struct bool_entry bool_entries[9];
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_CONFIGURATION_SETTINGS), parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_CONFIGURATION_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info,
parent_group);
bool_entries[listing].target = &settings->bools.config_save_on_exit;
bool_entries[listing].name_enum_idx = MENU_ENUM_LABEL_CONFIG_SAVE_ON_EXIT;
bool_entries[listing].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_CONFIG_SAVE_ON_EXIT;
bool_entries[listing].default_value = DEFAULT_CONFIG_SAVE_ON_EXIT;
bool_entries[listing].flags = SD_FLAG_NONE;
listing++;
bool_entries[listing].target = &settings->bools.show_hidden_files;
bool_entries[listing].name_enum_idx = MENU_ENUM_LABEL_SHOW_HIDDEN_FILES;
bool_entries[listing].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_SHOW_HIDDEN_FILES;
bool_entries[listing].default_value = DEFAULT_SHOW_HIDDEN_FILES;
bool_entries[listing].flags = SD_FLAG_NONE;
listing++;
bool_entries[listing].target = &settings->bools.game_specific_options;
bool_entries[listing].name_enum_idx = MENU_ENUM_LABEL_GAME_SPECIFIC_OPTIONS;
bool_entries[listing].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_GAME_SPECIFIC_OPTIONS;
bool_entries[listing].default_value = DEFAULT_GAME_SPECIFIC_OPTIONS;
bool_entries[listing].flags = SD_FLAG_ADVANCED;
listing++;
bool_entries[listing].target = &settings->bools.auto_overrides_enable;
bool_entries[listing].name_enum_idx = MENU_ENUM_LABEL_AUTO_OVERRIDES_ENABLE;
bool_entries[listing].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_AUTO_OVERRIDES_ENABLE;
bool_entries[listing].default_value = DEFAULT_AUTO_OVERRIDES_ENABLE;
bool_entries[listing].flags = SD_FLAG_ADVANCED;
listing++;
bool_entries[listing].target = &settings->bools.auto_remaps_enable;
bool_entries[listing].name_enum_idx = MENU_ENUM_LABEL_AUTO_REMAPS_ENABLE;
bool_entries[listing].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_AUTO_REMAPS_ENABLE;
bool_entries[listing].default_value = DEFAULT_AUTO_REMAPS_ENABLE;
bool_entries[listing].flags = SD_FLAG_ADVANCED;
listing++;
bool_entries[listing].target = &settings->bools.initial_disk_change_enable;
bool_entries[listing].name_enum_idx = MENU_ENUM_LABEL_INITIAL_DISK_CHANGE_ENABLE;
bool_entries[listing].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_INITIAL_DISK_CHANGE_ENABLE;
bool_entries[listing].default_value = DEFAULT_INITIAL_DISK_CHANGE_ENABLE;
bool_entries[listing].flags = SD_FLAG_ADVANCED;
listing++;
bool_entries[listing].target = &settings->bools.auto_shaders_enable;
bool_entries[listing].name_enum_idx = MENU_ENUM_LABEL_AUTO_SHADERS_ENABLE;
bool_entries[listing].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_AUTO_SHADERS_ENABLE;
bool_entries[listing].default_value = DEFAULT_AUTO_SHADERS_ENABLE;
bool_entries[listing].flags = SD_FLAG_NONE;
listing++;
bool_entries[listing].target = &settings->bools.global_core_options;
bool_entries[listing].name_enum_idx = MENU_ENUM_LABEL_GLOBAL_CORE_OPTIONS;
bool_entries[listing].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_GLOBAL_CORE_OPTIONS;
bool_entries[listing].default_value = DEFAULT_GLOBAL_CORE_OPTIONS;
bool_entries[listing].flags = SD_FLAG_NONE;
listing++;
bool_entries[listing].target = &settings->bools.remap_save_on_exit;
bool_entries[listing].name_enum_idx = MENU_ENUM_LABEL_REMAP_SAVE_ON_EXIT;
bool_entries[listing].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_REMAP_SAVE_ON_EXIT;
bool_entries[listing].default_value = DEFAULT_REMAP_SAVE_ON_EXIT;
bool_entries[listing].flags = SD_FLAG_NONE;
listing++;
for (i = 0; i < ARRAY_SIZE(bool_entries); i++)
{
CONFIG_BOOL(
list, list_info,
bool_entries[i].target,
bool_entries[i].name_enum_idx,
bool_entries[i].SHORT_enum_idx,
bool_entries[i].default_value,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
bool_entries[i].flags);
}
CONFIG_BOOL(
list, list_info,
&settings->bools.video_shader_enable,
MENU_ENUM_LABEL_VIDEO_SHADERS_ENABLE,
MENU_ENUM_LABEL_VALUE_VIDEO_SHADERS_ENABLE,
DEFAULT_SHADER_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.video_shader_preset_save_reference_enable,
MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_SAVE_REFERENCE,
MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET_SAVE_REFERENCE,
DEFAULT_VIDEO_SHADER_PRESET_SAVE_REFERENCE_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
}
break;
case SETTINGS_LIST_LOGGING:
{
bool *tmp_b = NULL;
START_GROUP(list, list_info, &group_info, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_LOGGING_SETTINGS), parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_LOGGING_SETTINGS);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info,
parent_group);
CONFIG_BOOL(
list, list_info,
verbosity_get_ptr(),
MENU_ENUM_LABEL_LOG_VERBOSITY,
MENU_ENUM_LABEL_VALUE_LOG_VERBOSITY,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
write_handler_logging_verbosity,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].action_ok = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_bool_action_right_with_refresh;
CONFIG_UINT(
list, list_info,
&settings->uints.frontend_log_level,
MENU_ENUM_LABEL_FRONTEND_LOG_LEVEL,
MENU_ENUM_LABEL_VALUE_FRONTEND_LOG_LEVEL,
DEFAULT_FRONTEND_LOG_LEVEL,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].change_handler = frontend_log_level_change_handler;
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_RADIO_BUTTONS;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0, 3, 1.0, true, true);
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_libretro_log_level;
CONFIG_UINT(
list, list_info,
&settings->uints.libretro_log_level,
MENU_ENUM_LABEL_LIBRETRO_LOG_LEVEL,
MENU_ENUM_LABEL_VALUE_LIBRETRO_LOG_LEVEL,
DEFAULT_LIBRETRO_LOG_LEVEL,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_RADIO_BUTTONS;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0, 3, 1.0, true, true);
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_libretro_log_level;
CONFIG_BOOL(
list, list_info,
&settings->bools.log_to_file,
MENU_ENUM_LABEL_LOG_TO_FILE,
MENU_ENUM_LABEL_VALUE_LOG_TO_FILE,
DEFAULT_LOG_TO_FILE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].action_ok = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_bool_action_right_with_refresh;
CONFIG_BOOL(
list, list_info,
&settings->bools.log_to_file_timestamp,
MENU_ENUM_LABEL_LOG_TO_FILE_TIMESTAMP,
MENU_ENUM_LABEL_VALUE_LOG_TO_FILE_TIMESTAMP,
DEFAULT_LOG_TO_FILE_TIMESTAMP,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
END_SUB_GROUP(list, list_info, parent_group);
START_SUB_GROUP(list, list_info, "Performance Counters", &group_info, &subgroup_info,
parent_group);
retroarch_ctl(RARCH_CTL_GET_PERFCNT, &tmp_b);
CONFIG_BOOL(
list, list_info,
tmp_b,
MENU_ENUM_LABEL_PERFCNT_ENABLE,
MENU_ENUM_LABEL_VALUE_PERFCNT_ENABLE,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED);
}
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
case SETTINGS_LIST_SAVING:
{
uint8_t i, listing = 0;
struct bool_entry bool_entries[12];
START_GROUP(list, list_info, &group_info, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_SAVING_SETTINGS), parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_SAVING_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info,
parent_group);
bool_entries[listing].target = &settings->bools.sort_savefiles_enable;
bool_entries[listing].name_enum_idx = MENU_ENUM_LABEL_SORT_SAVEFILES_ENABLE;
bool_entries[listing].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_SORT_SAVEFILES_ENABLE;
bool_entries[listing].default_value = DEFAULT_SORT_SAVEFILES_ENABLE;
bool_entries[listing].flags = SD_FLAG_ADVANCED;
listing++;
bool_entries[listing].target = &settings->bools.sort_savestates_enable;
bool_entries[listing].name_enum_idx = MENU_ENUM_LABEL_SORT_SAVESTATES_ENABLE;
bool_entries[listing].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_SORT_SAVESTATES_ENABLE;
bool_entries[listing].default_value = DEFAULT_SORT_SAVESTATES_ENABLE;
bool_entries[listing].flags = SD_FLAG_ADVANCED;
listing++;
bool_entries[listing].target = &settings->bools.sort_savefiles_by_content_enable;
bool_entries[listing].name_enum_idx = MENU_ENUM_LABEL_SORT_SAVEFILES_BY_CONTENT_ENABLE;
bool_entries[listing].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_SORT_SAVEFILES_BY_CONTENT_ENABLE;
bool_entries[listing].default_value = DEFAULT_SORT_SAVEFILES_BY_CONTENT_ENABLE;
bool_entries[listing].flags = SD_FLAG_ADVANCED;
listing++;
bool_entries[listing].target = &settings->bools.sort_savestates_by_content_enable;
bool_entries[listing].name_enum_idx = MENU_ENUM_LABEL_SORT_SAVESTATES_BY_CONTENT_ENABLE;
bool_entries[listing].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_SORT_SAVESTATES_BY_CONTENT_ENABLE;
bool_entries[listing].default_value = DEFAULT_SORT_SAVESTATES_BY_CONTENT_ENABLE;
bool_entries[listing].flags = SD_FLAG_ADVANCED;
listing++;
bool_entries[listing].target = &settings->bools.sort_screenshots_by_content_enable;
bool_entries[listing].name_enum_idx = MENU_ENUM_LABEL_SORT_SCREENSHOTS_BY_CONTENT_ENABLE;
bool_entries[listing].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_SORT_SCREENSHOTS_BY_CONTENT_ENABLE;
bool_entries[listing].default_value = DEFAULT_SORT_SCREENSHOTS_BY_CONTENT_ENABLE;
bool_entries[listing].flags = SD_FLAG_ADVANCED;
listing++;
bool_entries[listing].target = &settings->bools.block_sram_overwrite;
bool_entries[listing].name_enum_idx = MENU_ENUM_LABEL_BLOCK_SRAM_OVERWRITE;
bool_entries[listing].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_BLOCK_SRAM_OVERWRITE;
bool_entries[listing].default_value = DEFAULT_BLOCK_SRAM_OVERWRITE;
bool_entries[listing].flags = SD_FLAG_NONE;
listing++;
bool_entries[listing].target = &settings->bools.savestate_auto_save;
bool_entries[listing].name_enum_idx = MENU_ENUM_LABEL_SAVESTATE_AUTO_SAVE;
bool_entries[listing].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_SAVESTATE_AUTO_SAVE;
bool_entries[listing].default_value = DEFAULT_SAVESTATE_AUTO_SAVE;
bool_entries[listing].flags = SD_FLAG_NONE;
listing++;
bool_entries[listing].target = &settings->bools.savestate_auto_load;
bool_entries[listing].name_enum_idx = MENU_ENUM_LABEL_SAVESTATE_AUTO_LOAD;
bool_entries[listing].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_SAVESTATE_AUTO_LOAD;
bool_entries[listing].default_value = DEFAULT_SAVESTATE_AUTO_LOAD;
bool_entries[listing].flags = SD_FLAG_NONE;
listing++;
bool_entries[listing].target = &settings->bools.savestate_thumbnail_enable;
bool_entries[listing].name_enum_idx = MENU_ENUM_LABEL_SAVESTATE_THUMBNAIL_ENABLE;
bool_entries[listing].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_SAVESTATE_THUMBNAIL_ENABLE;
bool_entries[listing].default_value = DEFAULT_SAVESTATE_THUMBNAIL_ENABLE;
bool_entries[listing].flags = SD_FLAG_ADVANCED;
listing++;
bool_entries[listing].target = &settings->bools.savefiles_in_content_dir;
bool_entries[listing].name_enum_idx = MENU_ENUM_LABEL_SAVEFILES_IN_CONTENT_DIR_ENABLE;
bool_entries[listing].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_SAVEFILES_IN_CONTENT_DIR_ENABLE;
bool_entries[listing].default_value = DEFAULT_SAVEFILES_IN_CONTENT_DIR;
bool_entries[listing].flags = SD_FLAG_ADVANCED;
listing++;
bool_entries[listing].target = &settings->bools.savestates_in_content_dir;
bool_entries[listing].name_enum_idx = MENU_ENUM_LABEL_SAVESTATES_IN_CONTENT_DIR_ENABLE;
bool_entries[listing].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_SAVESTATES_IN_CONTENT_DIR_ENABLE;
bool_entries[listing].default_value = DEFAULT_SAVESTATES_IN_CONTENT_DIR;
bool_entries[listing].flags = SD_FLAG_ADVANCED;
listing++;
bool_entries[listing].target = &settings->bools.screenshots_in_content_dir;
bool_entries[listing].name_enum_idx = MENU_ENUM_LABEL_SCREENSHOTS_IN_CONTENT_DIR_ENABLE;
bool_entries[listing].SHORT_enum_idx = MENU_ENUM_LABEL_VALUE_SCREENSHOTS_IN_CONTENT_DIR_ENABLE;
bool_entries[listing].default_value = DEFAULT_SCREENSHOTS_IN_CONTENT_DIR;
bool_entries[listing].flags = SD_FLAG_ADVANCED;
listing++;
for (i = 0; i < ARRAY_SIZE(bool_entries); i++)
{
CONFIG_BOOL(
list, list_info,
bool_entries[i].target,
bool_entries[i].name_enum_idx,
bool_entries[i].SHORT_enum_idx,
bool_entries[i].default_value,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
bool_entries[i].flags);
}
#ifdef HAVE_THREADS
CONFIG_UINT(
list, list_info,
&settings->uints.autosave_interval,
MENU_ENUM_LABEL_AUTOSAVE_INTERVAL,
MENU_ENUM_LABEL_VALUE_AUTOSAVE_INTERVAL,
DEFAULT_AUTOSAVE_INTERVAL,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_AUTOSAVE_INIT);
menu_settings_list_current_add_range(list, list_info, 0, 0, 1, true, false);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_CMD_APPLY_AUTO);
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_autosave_interval;
#endif
CONFIG_BOOL(
list, list_info,
&settings->bools.savestate_auto_index,
MENU_ENUM_LABEL_SAVESTATE_AUTO_INDEX,
MENU_ENUM_LABEL_VALUE_SAVESTATE_AUTO_INDEX,
DEFAULT_SAVESTATE_AUTO_INDEX,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].action_ok = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_bool_action_right_with_refresh;
CONFIG_UINT(
list, list_info,
&settings->uints.savestate_max_keep,
MENU_ENUM_LABEL_SAVESTATE_MAX_KEEP,
MENU_ENUM_LABEL_VALUE_SAVESTATE_MAX_KEEP,
DEFAULT_SAVESTATE_MAX_KEEP,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0, 999, 1, true, true);
#ifdef HAVE_BSV_MOVIE
CONFIG_BOOL(
list, list_info,
&settings->bools.replay_auto_index,
MENU_ENUM_LABEL_REPLAY_AUTO_INDEX,
MENU_ENUM_LABEL_VALUE_REPLAY_AUTO_INDEX,
DEFAULT_REPLAY_AUTO_INDEX,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].action_ok = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_bool_action_right_with_refresh;
CONFIG_UINT(
list, list_info,
&settings->uints.replay_max_keep,
MENU_ENUM_LABEL_REPLAY_MAX_KEEP,
MENU_ENUM_LABEL_VALUE_REPLAY_MAX_KEEP,
DEFAULT_REPLAY_MAX_KEEP,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0, 999, 1, true, true);
CONFIG_UINT(
list, list_info,
&settings->uints.replay_checkpoint_interval,
MENU_ENUM_LABEL_REPLAY_CHECKPOINT_INTERVAL,
MENU_ENUM_LABEL_VALUE_REPLAY_CHECKPOINT_INTERVAL,
DEFAULT_REPLAY_CHECKPOINT_INTERVAL,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_replay_checkpoint_interval;
menu_settings_list_current_add_range(list, list_info, 0, 3600, 60, true, true);
#endif
CONFIG_BOOL(
list, list_info,
&settings->bools.content_runtime_log,
MENU_ENUM_LABEL_CONTENT_RUNTIME_LOG,
MENU_ENUM_LABEL_VALUE_CONTENT_RUNTIME_LOG,
DEFAULT_CONTENT_RUNTIME_LOG,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.content_runtime_log_aggregate,
MENU_ENUM_LABEL_CONTENT_RUNTIME_LOG_AGGREGATE,
MENU_ENUM_LABEL_VALUE_CONTENT_RUNTIME_LOG_AGGREGATE,
DEFAULT_CONTENT_RUNTIME_LOG_AGGREGATE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#if defined(HAVE_ZLIB)
CONFIG_BOOL(
list, list_info,
&settings->bools.save_file_compression,
MENU_ENUM_LABEL_SAVE_FILE_COMPRESSION,
MENU_ENUM_LABEL_VALUE_SAVE_FILE_COMPRESSION,
DEFAULT_SAVE_FILE_COMPRESSION,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.savestate_file_compression,
MENU_ENUM_LABEL_SAVESTATE_FILE_COMPRESSION,
MENU_ENUM_LABEL_VALUE_SAVESTATE_FILE_COMPRESSION,
DEFAULT_SAVESTATE_FILE_COMPRESSION,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#endif
/* TODO/FIXME: This is in the wrong group... */
CONFIG_BOOL(
list, list_info,
&settings->bools.scan_without_core_match,
MENU_ENUM_LABEL_SCAN_WITHOUT_CORE_MATCH,
MENU_ENUM_LABEL_VALUE_SCAN_WITHOUT_CORE_MATCH,
DEFAULT_SCAN_WITHOUT_CORE_MATCH,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.scan_serial_and_crc,
MENU_ENUM_LABEL_SCAN_SERIAL_AND_CRC,
MENU_ENUM_LABEL_VALUE_SCAN_SERIAL_AND_CRC,
DEFAULT_SCAN_SERIAL_AND_CRC,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_CLOUD_SYNC_SETTINGS,
MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
}
break;
case SETTINGS_LIST_CLOUD_SYNC:
#ifdef HAVE_CLOUDSYNC
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SETTINGS),
parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_CLOUD_SYNC_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
CONFIG_BOOL(
list, list_info,
&settings->bools.cloud_sync_enable,
MENU_ENUM_LABEL_CLOUD_SYNC_ENABLE,
MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_ENABLE,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.cloud_sync_destructive,
MENU_ENUM_LABEL_CLOUD_SYNC_DESTRUCTIVE,
MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_DESTRUCTIVE,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_STRING_OPTIONS(
list, list_info,
settings->arrays.cloud_sync_driver,
sizeof(settings->arrays.cloud_sync_driver),
MENU_ENUM_LABEL_CLOUD_SYNC_DRIVER,
MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_DRIVER,
"null",
config_get_cloud_sync_driver_options(),
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_IS_DRIVER);
(*list)[list_info->index - 1].action_ok = setting_action_ok_uint;
(*list)[list_info->index - 1].action_left = setting_string_action_left_driver;
(*list)[list_info->index - 1].action_right = setting_string_action_right_driver;
CONFIG_STRING(
list, list_info,
settings->arrays.webdav_url,
sizeof(settings->arrays.webdav_url),
MENU_ENUM_LABEL_CLOUD_SYNC_URL,
MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_URL,
"",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_STRING_LINE_EDIT;
(*list)[list_info->index - 1].action_start = setting_generic_action_start_default;
CONFIG_STRING(
list, list_info,
settings->arrays.webdav_username,
sizeof(settings->arrays.webdav_username),
MENU_ENUM_LABEL_CLOUD_SYNC_USERNAME,
MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_USERNAME,
"",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_STRING_LINE_EDIT;
(*list)[list_info->index - 1].action_start = setting_generic_action_start_default;
CONFIG_STRING(
list, list_info,
settings->arrays.webdav_password,
sizeof(settings->arrays.webdav_password),
MENU_ENUM_LABEL_CLOUD_SYNC_PASSWORD,
MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_PASSWORD,
"",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_password;
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_PASSWORD_LINE_EDIT;
(*list)[list_info->index - 1].action_start = setting_generic_action_start_default;
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
#endif
break;
case SETTINGS_LIST_FRAME_TIME_COUNTER:
START_GROUP(list, list_info, &group_info, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_FRAME_TIME_COUNTER_SETTINGS), parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_FRAME_TIME_COUNTER_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
CONFIG_BOOL(
list, list_info,
&settings->bools.frame_time_counter_reset_after_fastforwarding,
MENU_ENUM_LABEL_FRAME_TIME_COUNTER_RESET_AFTER_FASTFORWARDING,
MENU_ENUM_LABEL_VALUE_FRAME_TIME_COUNTER_RESET_AFTER_FASTFORWARDING,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.frame_time_counter_reset_after_load_state,
MENU_ENUM_LABEL_FRAME_TIME_COUNTER_RESET_AFTER_LOAD_STATE,
MENU_ENUM_LABEL_VALUE_FRAME_TIME_COUNTER_RESET_AFTER_LOAD_STATE,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.frame_time_counter_reset_after_save_state,
MENU_ENUM_LABEL_FRAME_TIME_COUNTER_RESET_AFTER_SAVE_STATE,
MENU_ENUM_LABEL_VALUE_FRAME_TIME_COUNTER_RESET_AFTER_SAVE_STATE,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
case SETTINGS_LIST_REWIND:
START_GROUP(list, list_info, &group_info, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_REWIND_SETTINGS), parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_REWIND_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
CONFIG_BOOL(
list, list_info,
&settings->bools.rewind_enable,
MENU_ENUM_LABEL_REWIND_ENABLE,
MENU_ENUM_LABEL_VALUE_REWIND_ENABLE,
DEFAULT_REWIND_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_CMD_APPLY_AUTO);
(*list)[list_info->index - 1].action_ok = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_bool_action_right_with_refresh;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_REWIND_TOGGLE);
CONFIG_UINT(
list, list_info,
&settings->uints.rewind_granularity,
MENU_ENUM_LABEL_REWIND_GRANULARITY,
MENU_ENUM_LABEL_VALUE_REWIND_GRANULARITY,
DEFAULT_REWIND_GRANULARITY,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].offset_by = 1;
menu_settings_list_current_add_range(list, list_info, 1, 32768, 1, true, true);
CONFIG_SIZE(
list, list_info,
&settings->sizes.rewind_buffer_size,
MENU_ENUM_LABEL_REWIND_BUFFER_SIZE,
MENU_ENUM_LABEL_VALUE_REWIND_BUFFER_SIZE,
DEFAULT_REWIND_BUFFER_SIZE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
&setting_get_string_representation_size_in_mb);
menu_settings_list_current_add_range(list,
list_info,
1024 * 1024,
1024 * 1024 * 1024,
settings->uints.rewind_buffer_size_step * 1024 * 1024,
true,
true);
CONFIG_UINT(
list, list_info,
&settings->uints.rewind_buffer_size_step,
MENU_ENUM_LABEL_REWIND_BUFFER_SIZE_STEP,
MENU_ENUM_LABEL_VALUE_REWIND_BUFFER_SIZE_STEP,
DEFAULT_REWIND_BUFFER_SIZE_STEP,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].offset_by = 1;
menu_settings_list_current_add_range(list, list_info, 1, 100, 1, true, true);
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
case SETTINGS_LIST_CHEATS:
{
START_GROUP(list, list_info, &group_info, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_CHEAT_SETTINGS), parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_CHEAT_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
CONFIG_BOOL(
list, list_info,
&settings->bools.apply_cheats_after_load,
MENU_ENUM_LABEL_CHEAT_APPLY_AFTER_LOAD,
MENU_ENUM_LABEL_VALUE_CHEAT_APPLY_AFTER_LOAD,
DEFAULT_APPLY_CHEATS_AFTER_LOAD,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_CMD_APPLY_AUTO);
CONFIG_BOOL(
list, list_info,
&settings->bools.apply_cheats_after_toggle,
MENU_ENUM_LABEL_CHEAT_APPLY_AFTER_TOGGLE,
MENU_ENUM_LABEL_VALUE_CHEAT_APPLY_AFTER_TOGGLE,
DEFAULT_APPLY_CHEATS_AFTER_TOGGLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_CMD_APPLY_AUTO);
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
}
case SETTINGS_LIST_CHEAT_DETAILS:
#ifdef HAVE_CHEATS
{
int max_bit_position;
if (!cheat_manager_state.cheats)
break;
START_GROUP(list, list_info, &group_info, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_CHEAT_DETAILS_SETTINGS), parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_CHEAT_DETAILS_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
CONFIG_UINT_CBS(cheat_manager_state.working_cheat.idx, CHEAT_IDX,
NULL,NULL,
0,&setting_get_string_representation_uint,0,cheat_manager_get_size()-1,1);
CONFIG_BOOL(
list, list_info,
&cheat_manager_state.working_cheat.state,
MENU_ENUM_LABEL_CHEAT_STATE,
MENU_ENUM_LABEL_VALUE_CHEAT_STATE,
cheat_manager_state.working_cheat.state,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_STRING(
list, list_info,
cheat_manager_state.working_desc,
sizeof(cheat_manager_state.working_desc),
MENU_ENUM_LABEL_CHEAT_DESC,
MENU_ENUM_LABEL_VALUE_CHEAT_DESC,
"",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
(*list)[list_info->index - 1].action_start = setting_generic_action_start_default;
CONFIG_STRING(
list, list_info,
cheat_manager_state.working_code,
sizeof(cheat_manager_state.working_code),
MENU_ENUM_LABEL_CHEAT_CODE,
MENU_ENUM_LABEL_VALUE_CHEAT_CODE,
"",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
(*list)[list_info->index - 1].action_start = setting_generic_action_start_default;
CONFIG_UINT_CBS(cheat_manager_state.working_cheat.handler, CHEAT_HANDLER,
setting_uint_action_left_with_refresh,setting_uint_action_right_with_refresh,
MENU_ENUM_LABEL_CHEAT_HANDLER_TYPE_EMU,
&setting_get_string_representation_uint_as_enum,
CHEAT_HANDLER_TYPE_EMU,CHEAT_HANDLER_TYPE_RETRO,1);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
CONFIG_STRING(
list, list_info,
cheat_manager_state.working_code,
sizeof(cheat_manager_state.working_code),
MENU_ENUM_LABEL_CHEAT_CODE,
MENU_ENUM_LABEL_VALUE_CHEAT_CODE,
"",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = setting_generic_action_start_default;
CONFIG_UINT_CBS(cheat_manager_state.working_cheat.memory_search_size, CHEAT_MEMORY_SEARCH_SIZE,
setting_uint_action_left_with_refresh,setting_uint_action_right_with_refresh,
MENU_ENUM_LABEL_CHEAT_MEMORY_SIZE_1,
&setting_get_string_representation_uint_as_enum,
0,5,1);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
CONFIG_UINT_CBS(cheat_manager_state.working_cheat.cheat_type, CHEAT_TYPE,
setting_uint_action_left_default,setting_uint_action_right_default,
MENU_ENUM_LABEL_CHEAT_TYPE_DISABLED,
&setting_get_string_representation_uint_as_enum,
CHEAT_TYPE_DISABLED,CHEAT_TYPE_RUN_NEXT_IF_GT,1);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
CONFIG_UINT_CBS(cheat_manager_state.working_cheat.value, CHEAT_VALUE,
setting_uint_action_left_default,
setting_uint_action_right_default,
0,
&setting_get_string_representation_hex_and_uint,
0,
cheat_manager_get_state_search_size(cheat_manager_state.working_cheat.memory_search_size),
1);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
CONFIG_UINT_CBS(cheat_manager_state.working_cheat.address,
CHEAT_ADDRESS,
setting_uint_action_left_with_refresh,
setting_uint_action_right_with_refresh,
0,
&setting_get_string_representation_hex_and_uint,
0,
(cheat_manager_state.total_memory_size == 0)
? 0
: (cheat_manager_state.total_memory_size - 1),
1);
max_bit_position = (cheat_manager_state.working_cheat.memory_search_size < 3) ? 255 : 0;
CONFIG_UINT_CBS(cheat_manager_state.working_cheat.address_mask,
CHEAT_ADDRESS_BIT_POSITION,
setting_uint_action_left_default,setting_uint_action_right_default,
0,
&setting_get_string_representation_hex_and_uint,
0,
max_bit_position,
1);
CONFIG_BOOL(
list, list_info,
&cheat_manager_state.working_cheat.big_endian,
MENU_ENUM_LABEL_CHEAT_BIG_ENDIAN,
MENU_ENUM_LABEL_VALUE_CHEAT_BIG_ENDIAN,
cheat_manager_state.working_cheat.big_endian,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_UINT_CBS(cheat_manager_state.working_cheat.repeat_count,
CHEAT_REPEAT_COUNT,
setting_uint_action_left_default,
setting_uint_action_right_default,
0,
&setting_get_string_representation_hex_and_uint,
1,
2048,
1);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
CONFIG_UINT_CBS(cheat_manager_state.working_cheat.repeat_add_to_address,
CHEAT_REPEAT_ADD_TO_ADDRESS,
setting_uint_action_left_default,setting_uint_action_right_default,
0,
&setting_get_string_representation_hex_and_uint,
1,
2048,
1);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
CONFIG_UINT_CBS(cheat_manager_state.working_cheat.repeat_add_to_value,
CHEAT_REPEAT_ADD_TO_VALUE,
setting_uint_action_left_default,
setting_uint_action_right_default,
0,
&setting_get_string_representation_hex_and_uint,
0,
0xFFFF,
1);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
CONFIG_UINT_CBS(cheat_manager_state.working_cheat.rumble_type, CHEAT_RUMBLE_TYPE,
setting_uint_action_left_default,setting_uint_action_right_default,
MENU_ENUM_LABEL_RUMBLE_TYPE_DISABLED,
&setting_get_string_representation_uint_as_enum,
RUMBLE_TYPE_DISABLED,RUMBLE_TYPE_END_LIST-1,1);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
CONFIG_UINT_CBS(cheat_manager_state.working_cheat.rumble_value,
CHEAT_RUMBLE_VALUE,
setting_uint_action_left_default,
setting_uint_action_right_default,
0,
&setting_get_string_representation_hex_and_uint,
0,
cheat_manager_get_state_search_size(cheat_manager_state.working_cheat.memory_search_size),
1);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
CONFIG_UINT_CBS(cheat_manager_state.working_cheat.rumble_port, CHEAT_RUMBLE_PORT,
setting_uint_action_left_default,setting_uint_action_right_default,
MENU_ENUM_LABEL_RUMBLE_PORT_0,
&setting_get_string_representation_uint_as_enum,
0,16,1);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
CONFIG_UINT_CBS(cheat_manager_state.working_cheat.rumble_primary_strength,
CHEAT_RUMBLE_PRIMARY_STRENGTH,
setting_uint_action_left_default,setting_uint_action_right_default,
0,
&setting_get_string_representation_hex_and_uint,
0,
65535,
1);
CONFIG_UINT_CBS(cheat_manager_state.working_cheat.rumble_primary_duration, CHEAT_RUMBLE_PRIMARY_DURATION,
setting_uint_action_left_default,setting_uint_action_right_default,
0,&setting_get_string_representation_uint,0,5000,1);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
CONFIG_UINT_CBS(cheat_manager_state.working_cheat.rumble_secondary_strength,
CHEAT_RUMBLE_SECONDARY_STRENGTH,
setting_uint_action_left_default,
setting_uint_action_right_default,
0,
&setting_get_string_representation_hex_and_uint,
0,
65535,
1);
CONFIG_UINT_CBS(cheat_manager_state.working_cheat.rumble_secondary_duration, CHEAT_RUMBLE_SECONDARY_DURATION,
setting_uint_action_left_default,setting_uint_action_right_default,
0,&setting_get_string_representation_uint,0,5000,1);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
}
#endif
break;
case SETTINGS_LIST_CHEAT_SEARCH:
#ifdef HAVE_CHEATS
if (!cheat_manager_state.cheats)
break;
START_GROUP(list, list_info, &group_info, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_CHEAT_SEARCH_SETTINGS), parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_CHEAT_SEARCH_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
CONFIG_UINT_CBS(cheat_manager_state.search_bit_size,
CHEAT_START_OR_RESTART,
setting_uint_action_left_with_refresh,
setting_uint_action_right_with_refresh,
MENU_ENUM_LABEL_CHEAT_MEMORY_SIZE_1,
&setting_get_string_representation_uint_as_enum,
0,5,1);
(*list)[list_info->index - 1].action_ok = &cheat_manager_initialize_memory;
CONFIG_BOOL(
list, list_info,
&cheat_manager_state.big_endian,
MENU_ENUM_LABEL_CHEAT_BIG_ENDIAN,
MENU_ENUM_LABEL_VALUE_CHEAT_BIG_ENDIAN,
cheat_manager_state.big_endian,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_UINT(
list, list_info,
&cheat_manager_state.search_exact_value,
MENU_ENUM_LABEL_CHEAT_SEARCH_EXACT,
MENU_ENUM_LABEL_VALUE_CHEAT_SEARCH_EXACT,
cheat_manager_state.search_exact_value,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
menu_settings_list_current_add_range(list, list_info,
0, cheat_manager_get_state_search_size(cheat_manager_state.search_bit_size), 1, true, true);
(*list)[list_info->index - 1].get_string_representation = &setting_get_string_representation_uint_cheat_exact;
(*list)[list_info->index - 1].action_ok = &cheat_manager_search_exact;
CONFIG_UINT(
list, list_info,
&cheat_manager_state.dummy,
MENU_ENUM_LABEL_CHEAT_SEARCH_LT,
MENU_ENUM_LABEL_VALUE_CHEAT_SEARCH_LT,
cheat_manager_state.dummy,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].get_string_representation = &setting_get_string_representation_uint_cheat_lt;
(*list)[list_info->index - 1].action_ok = &cheat_manager_search_lt;
CONFIG_UINT(
list, list_info,
&cheat_manager_state.dummy,
MENU_ENUM_LABEL_CHEAT_SEARCH_LTE,
MENU_ENUM_LABEL_VALUE_CHEAT_SEARCH_LTE,
cheat_manager_state.dummy,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].get_string_representation = &setting_get_string_representation_uint_cheat_lte;
(*list)[list_info->index - 1].action_ok = &cheat_manager_search_lte;
CONFIG_UINT(
list, list_info,
&cheat_manager_state.dummy,
MENU_ENUM_LABEL_CHEAT_SEARCH_GT,
MENU_ENUM_LABEL_VALUE_CHEAT_SEARCH_GT,
cheat_manager_state.dummy,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].get_string_representation = &setting_get_string_representation_uint_cheat_gt;
(*list)[list_info->index - 1].action_ok = &cheat_manager_search_gt;
CONFIG_UINT(
list, list_info,
&cheat_manager_state.dummy,
MENU_ENUM_LABEL_CHEAT_SEARCH_GTE,
MENU_ENUM_LABEL_VALUE_CHEAT_SEARCH_GTE,
cheat_manager_state.dummy,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].get_string_representation = &setting_get_string_representation_uint_cheat_gte;
(*list)[list_info->index - 1].action_ok = &cheat_manager_search_gte;
CONFIG_UINT(
list, list_info,
&cheat_manager_state.dummy,
MENU_ENUM_LABEL_CHEAT_SEARCH_EQ,
MENU_ENUM_LABEL_VALUE_CHEAT_SEARCH_EQ,
cheat_manager_state.dummy,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].get_string_representation = &setting_get_string_representation_uint_cheat_eq;
(*list)[list_info->index - 1].action_ok = &cheat_manager_search_eq;
CONFIG_UINT(
list, list_info,
&cheat_manager_state.dummy,
MENU_ENUM_LABEL_CHEAT_SEARCH_NEQ,
MENU_ENUM_LABEL_VALUE_CHEAT_SEARCH_NEQ,
cheat_manager_state.dummy,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].get_string_representation = &setting_get_string_representation_uint_cheat_neq;
(*list)[list_info->index - 1].action_ok = &cheat_manager_search_neq;
CONFIG_UINT(
list, list_info,
&cheat_manager_state.search_eqplus_value,
MENU_ENUM_LABEL_CHEAT_SEARCH_EQPLUS,
MENU_ENUM_LABEL_VALUE_CHEAT_SEARCH_EQPLUS,
cheat_manager_state.search_eqplus_value,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
menu_settings_list_current_add_range(list, list_info,
0, cheat_manager_get_state_search_size(cheat_manager_state.search_bit_size), 1, true, true);
(*list)[list_info->index - 1].get_string_representation = &setting_get_string_representation_uint_cheat_eqplus;
(*list)[list_info->index - 1].action_ok = &cheat_manager_search_eqplus;
CONFIG_UINT(
list, list_info,
&cheat_manager_state.search_eqminus_value,
MENU_ENUM_LABEL_CHEAT_SEARCH_EQMINUS,
MENU_ENUM_LABEL_VALUE_CHEAT_SEARCH_EQMINUS,
cheat_manager_state.search_eqminus_value,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
menu_settings_list_current_add_range(list, list_info,
0, cheat_manager_get_state_search_size(cheat_manager_state.search_bit_size), 1, true, true);
(*list)[list_info->index - 1].get_string_representation = &setting_get_string_representation_uint_cheat_eqminus;
(*list)[list_info->index - 1].action_ok = &cheat_manager_search_eqminus;
CONFIG_UINT(
list, list_info,
&cheat_manager_state.match_idx,
MENU_ENUM_LABEL_CHEAT_DELETE_MATCH,
MENU_ENUM_LABEL_VALUE_CHEAT_DELETE_MATCH,
cheat_manager_state.match_idx,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
menu_settings_list_current_add_range(list, list_info, 0, cheat_manager_state.num_matches-1, 1, true, true);
(*list)[list_info->index - 1].action_left = &setting_uint_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_uint_action_right_with_refresh;
(*list)[list_info->index - 1].action_ok = &cheat_manager_delete_match;
CONFIG_UINT(
list, list_info,
&cheat_manager_state.match_idx,
MENU_ENUM_LABEL_CHEAT_COPY_MATCH,
MENU_ENUM_LABEL_VALUE_CHEAT_COPY_MATCH,
cheat_manager_state.match_idx,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
menu_settings_list_current_add_range(list, list_info, 0, cheat_manager_state.num_matches-1, 1, true, true);
(*list)[list_info->index - 1].action_left = &setting_uint_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_uint_action_right_with_refresh;
(*list)[list_info->index - 1].action_ok = &cheat_manager_copy_match;
CONFIG_UINT(
list, list_info,
&cheat_manager_state.browse_address,
MENU_ENUM_LABEL_CHEAT_BROWSE_MEMORY,
MENU_ENUM_LABEL_VALUE_CHEAT_BROWSE_MEMORY,
cheat_manager_state.browse_address,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
menu_settings_list_current_add_range(list, list_info, 0,
(cheat_manager_state.total_memory_size > 0)
? (cheat_manager_state.total_memory_size - 1)
: 0,
1,
true,
true);
(*list)[list_info->index - 1].action_left = &setting_uint_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_uint_action_right_with_refresh;
(*list)[list_info->index - 1].get_string_representation = &setting_get_string_representation_uint_cheat_browse_address;
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
#endif
break;
case SETTINGS_LIST_VIDEO:
{
struct video_viewport *custom_vp = &settings->video_viewport_custom;
START_GROUP(list, list_info, &group_info, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SETTINGS), parent_group);
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_IDX_PTR(list, list_info, MENU_ENUM_LABEL_VIDEO_SETTINGS);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
#if (!defined(RARCH_CONSOLE) && !defined(RARCH_MOBILE)) || (defined(IOS) && TARGET_OS_TV)
CONFIG_BOOL(
list, list_info,
&settings->bools.ui_suspend_screensaver_enable,
MENU_ENUM_LABEL_SUSPEND_SCREENSAVER_ENABLE,
MENU_ENUM_LABEL_VALUE_SUSPEND_SCREENSAVER_ENABLE,
true,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
#endif
END_SUB_GROUP(list, list_info, parent_group);
START_SUB_GROUP(list, list_info, "Platform-specific", &group_info, &subgroup_info, parent_group);
video_driver_menu_settings((void**)list, (void*)list_info, (void*)&group_info, (void*)&subgroup_info, parent_group);
END_SUB_GROUP(list, list_info, parent_group);
START_SUB_GROUP(list, list_info, "Monitor", &group_info, &subgroup_info, parent_group);
CONFIG_UINT(
list, list_info,
&settings->uints.video_monitor_index,
MENU_ENUM_LABEL_VIDEO_MONITOR_INDEX,
MENU_ENUM_LABEL_VALUE_VIDEO_MONITOR_INDEX,
DEFAULT_MONITOR_INDEX,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_REINIT);
menu_settings_list_current_add_range(list, list_info, 0, 1, 1, true, false);
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_video_monitor_index;
/* prevent unused function warning on unsupported builds */
(void)setting_get_string_representation_int_gpu_index;
#if defined(ANDROID) || TARGET_OS_IOS
CONFIG_BOOL(
list, list_info,
&settings->bools.video_notch_write_over_enable,
MENU_ENUM_LABEL_VIDEO_NOTCH_WRITE_OVER,
MENU_ENUM_LABEL_VALUE_VIDEO_NOTCH_WRITE_OVER,
DEFAULT_NOTCH_WRITE_OVER_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#endif
#ifdef HAVE_VULKAN
if (string_is_equal(video_driver_get_ident(), "vulkan"))
{
CONFIG_INT(
list, list_info,
&settings->ints.vulkan_gpu_index,
MENU_ENUM_LABEL_VIDEO_GPU_INDEX,
MENU_ENUM_LABEL_VALUE_VIDEO_GPU_INDEX,
0,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
menu_settings_list_current_add_range(list, list_info, 0, 15, 1, true, true);
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_int_gpu_index;
}
#endif
#ifdef HAVE_D3D10
if (string_is_equal(video_driver_get_ident(), "d3d10"))
{
CONFIG_INT(
list, list_info,
&settings->ints.d3d10_gpu_index,
MENU_ENUM_LABEL_VIDEO_GPU_INDEX,
MENU_ENUM_LABEL_VALUE_VIDEO_GPU_INDEX,
0,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
menu_settings_list_current_add_range(list, list_info, 0, 15, 1, true, true);
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_int_gpu_index;
}
#endif
#ifdef HAVE_D3D11
if (string_is_equal(video_driver_get_ident(), "d3d11"))
{
CONFIG_INT(
list, list_info,
&settings->ints.d3d11_gpu_index,
MENU_ENUM_LABEL_VIDEO_GPU_INDEX,
MENU_ENUM_LABEL_VALUE_VIDEO_GPU_INDEX,
0,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
menu_settings_list_current_add_range(list, list_info, 0, 15, 1, true, true);
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_int_gpu_index;
}
#endif
#ifdef HAVE_D3D12
if (string_is_equal(video_driver_get_ident(), "d3d12"))
{
CONFIG_INT(
list, list_info,
&settings->ints.d3d12_gpu_index,
MENU_ENUM_LABEL_VIDEO_GPU_INDEX,
MENU_ENUM_LABEL_VALUE_VIDEO_GPU_INDEX,
0,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
menu_settings_list_current_add_range(list, list_info, 0, 15, 1, true, true);
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_int_gpu_index;
}
#endif
#ifdef WIIU
CONFIG_BOOL(
list, list_info,
&settings->bools.video_wiiu_prefer_drc,
MENU_ENUM_LABEL_VIDEO_WIIU_PREFER_DRC,
MENU_ENUM_LABEL_VALUE_VIDEO_WIIU_PREFER_DRC,
DEFAULT_WIIU_PREFER_DRC,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#endif
if (video_driver_has_windowed())
{
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_VIDEO_FULLSCREEN_MODE_SETTINGS,
MENU_ENUM_LABEL_VALUE_VIDEO_FULLSCREEN_MODE_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_VIDEO_WINDOWED_MODE_SETTINGS,
MENU_ENUM_LABEL_VALUE_VIDEO_WINDOWED_MODE_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
}
CONFIG_BOOL(
list, list_info,
&settings->bools.video_fullscreen,
MENU_ENUM_LABEL_VIDEO_FULLSCREEN,
MENU_ENUM_LABEL_VALUE_VIDEO_FULLSCREEN,
DEFAULT_FULLSCREEN,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_CMD_APPLY_AUTO);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_REINIT_FROM_TOGGLE);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
{
CONFIG_BOOL(
list, list_info,
&settings->bools.video_windowed_fullscreen,
MENU_ENUM_LABEL_VIDEO_WINDOWED_FULLSCREEN,
MENU_ENUM_LABEL_VALUE_VIDEO_WINDOWED_FULLSCREEN,
DEFAULT_WINDOWED_FULLSCREEN,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_UINT(
list, list_info,
&settings->uints.video_fullscreen_x,
MENU_ENUM_LABEL_VIDEO_FULLSCREEN_X,
MENU_ENUM_LABEL_VALUE_VIDEO_FULLSCREEN_X,
DEFAULT_FULLSCREEN_X,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint_special;
menu_settings_list_current_add_range(list, list_info, 0, 7680, 8, true, true);
CONFIG_UINT(
list, list_info,
&settings->uints.video_fullscreen_y,
MENU_ENUM_LABEL_VIDEO_FULLSCREEN_Y,
MENU_ENUM_LABEL_VALUE_VIDEO_FULLSCREEN_Y,
DEFAULT_FULLSCREEN_Y,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint_special;
menu_settings_list_current_add_range(list, list_info, 0, 4320, 8, true, true);
}
#if defined(DINGUX) && defined(DINGUX_BETA)
if (string_is_equal(settings->arrays.video_driver, "sdl_dingux") ||
string_is_equal(settings->arrays.video_driver, "sdl_rs90"))
{
CONFIG_UINT(
list, list_info,
&settings->uints.video_dingux_refresh_rate,
MENU_ENUM_LABEL_VIDEO_DINGUX_REFRESH_RATE,
MENU_ENUM_LABEL_VALUE_VIDEO_DINGUX_REFRESH_RATE,
DEFAULT_DINGUX_REFRESH_RATE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_video_dingux_refresh_rate;
menu_settings_list_current_add_range(list, list_info, 0, DINGUX_REFRESH_RATE_LAST - 1, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
}
else
#endif
{
float actual_refresh_rate = video_driver_get_refresh_rate();
CONFIG_FLOAT(
list, list_info,
&settings->floats.video_refresh_rate,
MENU_ENUM_LABEL_VIDEO_REFRESH_RATE,
MENU_ENUM_LABEL_VALUE_VIDEO_REFRESH_RATE,
DEFAULT_REFRESH_RATE,
"%.3f Hz",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
menu_settings_list_current_add_range(list, list_info, 0, 0, 0.001, true, false);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_FLOAT(
list, list_info,
&settings->floats.video_refresh_rate,
MENU_ENUM_LABEL_VIDEO_REFRESH_RATE_AUTO,
MENU_ENUM_LABEL_VALUE_VIDEO_REFRESH_RATE_AUTO,
DEFAULT_REFRESH_RATE,
"%.3f Hz",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = &setting_action_start_video_refresh_rate_auto;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_video_refresh_rate_auto;
(*list)[list_info->index - 1].action_select = &setting_action_ok_video_refresh_rate_auto;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_st_float_video_refresh_rate_auto;
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
if (actual_refresh_rate > 0.0)
{
CONFIG_FLOAT(
list, list_info,
&settings->floats.video_refresh_rate,
MENU_ENUM_LABEL_VIDEO_REFRESH_RATE_POLLED,
MENU_ENUM_LABEL_VALUE_VIDEO_REFRESH_RATE_POLLED,
actual_refresh_rate,
"%.3f Hz",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = &setting_action_start_video_refresh_rate_polled;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_video_refresh_rate_polled;
(*list)[list_info->index - 1].action_select = &setting_action_ok_video_refresh_rate_polled;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_st_float_video_refresh_rate_polled;
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
}
}
CONFIG_UINT(
list, list_info,
&settings->uints.video_autoswitch_refresh_rate,
MENU_ENUM_LABEL_VIDEO_AUTOSWITCH_REFRESH_RATE,
MENU_ENUM_LABEL_VALUE_VIDEO_AUTOSWITCH_REFRESH_RATE,
DEFAULT_AUTOSWITCH_REFRESH_RATE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_video_autoswitch_refresh_rate;
menu_settings_list_current_add_range(list, list_info, 0, AUTOSWITCH_REFRESH_RATE_LAST - 1, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
CONFIG_FLOAT(
list, list_info,
&settings->floats.video_autoswitch_pal_threshold,
MENU_ENUM_LABEL_VIDEO_AUTOSWITCH_PAL_THRESHOLD,
MENU_ENUM_LABEL_VALUE_VIDEO_AUTOSWITCH_PAL_THRESHOLD,
DEFAULT_AUTOSWITCH_PAL_THRESHOLD,
"%.3f Hz",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
menu_settings_list_current_add_range(list, list_info, 50, 56, 0.1, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
if (string_is_equal(settings->arrays.video_driver, "gl"))
{
CONFIG_BOOL(
list, list_info,
&settings->bools.video_force_srgb_disable,
MENU_ENUM_LABEL_VIDEO_FORCE_SRGB_DISABLE,
MENU_ENUM_LABEL_VALUE_VIDEO_FORCE_SRGB_DISABLE,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_CMD_APPLY_AUTO | SD_FLAG_ADVANCED
);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_REINIT);
}
END_SUB_GROUP(list, list_info, parent_group);
START_SUB_GROUP(list, list_info, "Aspect", &group_info, &subgroup_info, parent_group);
CONFIG_UINT(
list, list_info,
&settings->uints.video_aspect_ratio_idx,
MENU_ENUM_LABEL_VIDEO_ASPECT_RATIO_INDEX,
MENU_ENUM_LABEL_VALUE_VIDEO_ASPECT_RATIO_INDEX,
DEFAULT_ASPECT_RATIO_IDX,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(
list,
list_info,
CMD_EVENT_VIDEO_SET_ASPECT_RATIO);
menu_settings_list_current_add_range(
list,
list_info,
0,
LAST_ASPECT_RATIO,
1,
true,
true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_CMD_APPLY_AUTO);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_aspect_ratio_index;
(*list)[list_info->index - 1].action_left = setting_uint_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = setting_uint_action_right_with_refresh;
CONFIG_FLOAT(
list, list_info,
&settings->floats.video_aspect_ratio,
MENU_ENUM_LABEL_VIDEO_ASPECT_RATIO,
MENU_ENUM_LABEL_VALUE_VIDEO_ASPECT_RATIO,
DEFAULT_ASPECT_RATIO,
"%.2f",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(
list,
list_info,
CMD_EVENT_VIDEO_SET_ASPECT_RATIO);
menu_settings_list_current_add_range(list, list_info, 0.1, 16.0, 0.01, true, false);
CONFIG_INT(
list, list_info,
&custom_vp->x,
MENU_ENUM_LABEL_VIDEO_VIEWPORT_CUSTOM_X,
MENU_ENUM_LABEL_VALUE_VIDEO_VIEWPORT_CUSTOM_X,
0,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
menu_settings_list_current_add_range(list, list_info, -9999, 9999, 1, true, true);
(*list)[list_info->index - 1].offset_by = -9999;
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info,
CMD_EVENT_VIDEO_APPLY_STATE_CHANGES);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_INT(
list, list_info,
&custom_vp->y,
MENU_ENUM_LABEL_VIDEO_VIEWPORT_CUSTOM_Y,
MENU_ENUM_LABEL_VALUE_VIDEO_VIEWPORT_CUSTOM_Y,
0,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
menu_settings_list_current_add_range(list, list_info, -9999, 9999, 1, true, true);
(*list)[list_info->index - 1].offset_by = -9999;
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info,
CMD_EVENT_VIDEO_APPLY_STATE_CHANGES);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
#if defined(GEKKO) || defined(PS2) || defined(__PS3__)
if (true)
#else
if (!string_is_equal(video_display_server_get_ident(), "null"))
#endif
{
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_SCREEN_RESOLUTION,
MENU_ENUM_LABEL_VALUE_SCREEN_RESOLUTION,
&group_info,
&subgroup_info,
parent_group);
}
#if defined(HAVE_WINDOW_OFFSET)
CONFIG_INT(
list, list_info,
&settings->ints.video_window_offset_x,
MENU_ENUM_LABEL_VIDEO_WINDOW_OFFSET_X,
MENU_ENUM_LABEL_VALUE_VIDEO_WINDOW_OFFSET_X,
DEFAULT_WINDOW_OFFSET_X,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
menu_settings_list_current_add_range(list, list_info, -50, 50, 1, true, true);
CONFIG_INT(
list, list_info,
&settings->ints.video_window_offset_y,
MENU_ENUM_LABEL_VIDEO_WINDOW_OFFSET_Y,
MENU_ENUM_LABEL_VALUE_VIDEO_WINDOW_OFFSET_Y,
DEFAULT_WINDOW_OFFSET_Y,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
menu_settings_list_current_add_range(list, list_info, -50, 50, 1, true, true);
#endif
CONFIG_UINT(
list, list_info,
&custom_vp->width,
MENU_ENUM_LABEL_VIDEO_VIEWPORT_CUSTOM_WIDTH,
MENU_ENUM_LABEL_VALUE_VIDEO_VIEWPORT_CUSTOM_WIDTH,
0,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
menu_settings_list_current_add_range(list, list_info, 1, 9999, 1, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_custom_viewport_width;
(*list)[list_info->index - 1].action_start = &setting_action_start_custom_viewport_width;
(*list)[list_info->index - 1].action_left = &setting_uint_action_left_custom_viewport_width;
(*list)[list_info->index - 1].action_right = &setting_uint_action_right_custom_viewport_width;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info,
CMD_EVENT_VIDEO_APPLY_STATE_CHANGES);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_UINT(
list, list_info,
&custom_vp->height,
MENU_ENUM_LABEL_VIDEO_VIEWPORT_CUSTOM_HEIGHT,
MENU_ENUM_LABEL_VALUE_VIDEO_VIEWPORT_CUSTOM_HEIGHT,
0,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
menu_settings_list_current_add_range(list, list_info, 1, 9999, 1, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_custom_viewport_height;
(*list)[list_info->index - 1].action_start = &setting_action_start_custom_viewport_height;
(*list)[list_info->index - 1].action_left = &setting_uint_action_left_custom_viewport_height;
(*list)[list_info->index - 1].action_right = &setting_uint_action_right_custom_viewport_height;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info,
CMD_EVENT_VIDEO_APPLY_STATE_CHANGES);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
#if defined(DINGUX)
if (string_is_equal(settings->arrays.video_driver, "sdl_dingux") ||
string_is_equal(settings->arrays.video_driver, "sdl_rs90"))
{
CONFIG_BOOL(
list, list_info,
&settings->bools.video_dingux_ipu_keep_aspect,
MENU_ENUM_LABEL_VIDEO_DINGUX_IPU_KEEP_ASPECT,
MENU_ENUM_LABEL_VALUE_VIDEO_DINGUX_IPU_KEEP_ASPECT,
DEFAULT_DINGUX_IPU_KEEP_ASPECT,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(
list,
list_info,
CMD_EVENT_VIDEO_APPLY_STATE_CHANGES);
}
#endif
END_SUB_GROUP(list, list_info, parent_group);
START_SUB_GROUP(list, list_info, "Scaling", &group_info, &subgroup_info, parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_VIDEO_SYNCHRONIZATION_SETTINGS,
MENU_ENUM_LABEL_VALUE_VIDEO_SYNCHRONIZATION_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_VIDEO_SCALING_SETTINGS,
MENU_ENUM_LABEL_VALUE_VIDEO_SCALING_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
if (video_driver_has_windowed())
{
CONFIG_UINT(
list, list_info,
&settings->uints.video_scale,
MENU_ENUM_LABEL_VIDEO_SCALE,
MENU_ENUM_LABEL_VALUE_VIDEO_SCALE,
DEFAULT_SCALE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].offset_by = 1;
menu_settings_list_current_add_range(list, list_info, 1, 10, 1, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_UINT(
list, list_info,
&settings->uints.window_position_width,
MENU_ENUM_LABEL_VIDEO_WINDOW_WIDTH,
MENU_ENUM_LABEL_VALUE_VIDEO_WINDOW_WIDTH,
DEFAULT_WINDOW_WIDTH,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint_special;
menu_settings_list_current_add_range(list, list_info, 0, 7680, 8, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_UINT(
list, list_info,
&settings->uints.window_position_height,
MENU_ENUM_LABEL_VIDEO_WINDOW_HEIGHT,
MENU_ENUM_LABEL_VALUE_VIDEO_WINDOW_HEIGHT,
DEFAULT_WINDOW_HEIGHT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint_special;
menu_settings_list_current_add_range(list, list_info, 0, 4320, 8, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_UINT(
list, list_info,
&settings->uints.window_auto_width_max,
MENU_ENUM_LABEL_VIDEO_WINDOW_AUTO_WIDTH_MAX,
MENU_ENUM_LABEL_VALUE_VIDEO_WINDOW_AUTO_WIDTH_MAX,
DEFAULT_WINDOW_AUTO_WIDTH_MAX,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint_special;
menu_settings_list_current_add_range(list, list_info, 0, 7680, 8, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_UINT(
list, list_info,
&settings->uints.window_auto_height_max,
MENU_ENUM_LABEL_VIDEO_WINDOW_AUTO_HEIGHT_MAX,
MENU_ENUM_LABEL_VALUE_VIDEO_WINDOW_AUTO_HEIGHT_MAX,
DEFAULT_WINDOW_AUTO_HEIGHT_MAX,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint_special;
menu_settings_list_current_add_range(list, list_info, 0, 4320, 8, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_UINT(
list, list_info,
&settings->uints.video_window_opacity,
MENU_ENUM_LABEL_VIDEO_WINDOW_OPACITY,
MENU_ENUM_LABEL_VALUE_VIDEO_WINDOW_OPACITY,
DEFAULT_WINDOW_OPACITY,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].offset_by = 1;
menu_settings_list_current_add_range(list, list_info, 1, 100, 1, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
}
CONFIG_BOOL(
list, list_info,
&settings->bools.video_window_show_decorations,
MENU_ENUM_LABEL_VIDEO_WINDOW_SHOW_DECORATIONS,
MENU_ENUM_LABEL_VALUE_VIDEO_WINDOW_SHOW_DECORATIONS,
DEFAULT_WINDOW_DECORATIONS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_REINIT);
#if defined(_WIN32) && !defined(_XBOX) && !defined(__WINRT__)
CONFIG_BOOL(
list, list_info,
&settings->bools.ui_menubar_enable,
MENU_ENUM_LABEL_UI_MENUBAR_ENABLE,
MENU_ENUM_LABEL_VALUE_UI_MENUBAR_ENABLE,
DEFAULT_UI_MENUBAR_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_REINIT);
#endif
#if (defined(_WIN32) && !defined(_XBOX) && !defined(__WINRT__)) || \
(defined(HAVE_COCOA_METAL) && !defined(HAVE_COCOATOUCH))
CONFIG_BOOL(
list, list_info,
&settings->bools.video_window_save_positions,
MENU_ENUM_LABEL_VIDEO_WINDOW_SAVE_POSITION,
MENU_ENUM_LABEL_VALUE_VIDEO_WINDOW_SAVE_POSITION,
DEFAULT_WINDOW_SAVE_POSITIONS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].action_ok = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = setting_bool_action_right_with_refresh;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_REINIT);
#else
CONFIG_BOOL(
list, list_info,
&settings->bools.video_window_custom_size_enable,
MENU_ENUM_LABEL_VIDEO_WINDOW_CUSTOM_SIZE_ENABLE,
MENU_ENUM_LABEL_VALUE_VIDEO_WINDOW_CUSTOM_SIZE_ENABLE,
DEFAULT_WINDOW_CUSTOM_SIZE_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].action_ok = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = setting_bool_action_right_with_refresh;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_REINIT);
#endif
CONFIG_BOOL(
list, list_info,
&settings->bools.video_scale_integer,
MENU_ENUM_LABEL_VIDEO_SCALE_INTEGER,
MENU_ENUM_LABEL_VALUE_VIDEO_SCALE_INTEGER,
DEFAULT_SCALE_INTEGER,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].action_ok = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = setting_bool_action_right_with_refresh;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(
list,
list_info,
CMD_EVENT_VIDEO_APPLY_STATE_CHANGES);
CONFIG_BOOL(
list, list_info,
&settings->bools.video_scale_integer_overscale,
MENU_ENUM_LABEL_VIDEO_SCALE_INTEGER_OVERSCALE,
MENU_ENUM_LABEL_VALUE_VIDEO_SCALE_INTEGER_OVERSCALE,
DEFAULT_SCALE_INTEGER_OVERSCALE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].action_ok = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = setting_bool_action_right_with_refresh;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(
list,
list_info,
CMD_EVENT_VIDEO_APPLY_STATE_CHANGES);
#ifdef GEKKO
CONFIG_UINT(
list, list_info,
&settings->uints.video_viwidth,
MENU_ENUM_LABEL_VIDEO_VI_WIDTH,
MENU_ENUM_LABEL_VALUE_VIDEO_VI_WIDTH,
DEFAULT_VIDEO_VI_WIDTH,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
menu_settings_list_current_add_range(list, list_info, 640, 720, 2, true, true);
CONFIG_BOOL(
list, list_info,
&settings->bools.video_vfilter,
MENU_ENUM_LABEL_VIDEO_VFILTER,
MENU_ENUM_LABEL_VALUE_VIDEO_VFILTER,
DEFAULT_VIDEO_VFILTER,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_UINT(
list, list_info,
&settings->uints.video_overscan_correction_top,
MENU_ENUM_LABEL_VIDEO_OVERSCAN_CORRECTION_TOP,
MENU_ENUM_LABEL_VALUE_VIDEO_OVERSCAN_CORRECTION_TOP,
DEFAULT_VIDEO_OVERSCAN_CORRECTION_TOP,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
menu_settings_list_current_add_range(list, list_info, 0, 24, 1, true, true);
CONFIG_UINT(
list, list_info,
&settings->uints.video_overscan_correction_bottom,
MENU_ENUM_LABEL_VIDEO_OVERSCAN_CORRECTION_BOTTOM,
MENU_ENUM_LABEL_VALUE_VIDEO_OVERSCAN_CORRECTION_BOTTOM,
DEFAULT_VIDEO_OVERSCAN_CORRECTION_BOTTOM,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
menu_settings_list_current_add_range(list, list_info, 0, 24, 1, true, true);
#endif
#if defined(DINGUX)
if (string_is_equal(settings->arrays.video_driver, "sdl_dingux"))
{
CONFIG_UINT(
list, list_info,
&settings->uints.video_dingux_ipu_filter_type,
MENU_ENUM_LABEL_VIDEO_DINGUX_IPU_FILTER_TYPE,
MENU_ENUM_LABEL_VALUE_VIDEO_DINGUX_IPU_FILTER_TYPE,
DEFAULT_DINGUX_IPU_FILTER_TYPE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_video_dingux_ipu_filter_type;
menu_settings_list_current_add_range(list, list_info, 0, DINGUX_IPU_FILTER_LAST - 1, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
}
#if defined(RS90) || defined(MIYOO)
else if (string_is_equal(settings->arrays.video_driver, "sdl_rs90"))
{
CONFIG_UINT(
list, list_info,
&settings->uints.video_dingux_rs90_softfilter_type,
MENU_ENUM_LABEL_VIDEO_DINGUX_RS90_SOFTFILTER_TYPE,
MENU_ENUM_LABEL_VALUE_VIDEO_DINGUX_RS90_SOFTFILTER_TYPE,
DEFAULT_DINGUX_RS90_SOFTFILTER_TYPE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_video_dingux_rs90_softfilter_type;
menu_settings_list_current_add_range(list, list_info, 0, DINGUX_RS90_SOFTFILTER_LAST - 1, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
}
#endif
else
#endif
{
CONFIG_BOOL(
list, list_info,
&settings->bools.video_smooth,
MENU_ENUM_LABEL_VIDEO_SMOOTH,
MENU_ENUM_LABEL_VALUE_VIDEO_SMOOTH,
DEFAULT_VIDEO_SMOOTH,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_REINIT);
}
#ifdef HAVE_ODROIDGO2
CONFIG_BOOL(
list, list_info,
&settings->bools.video_ctx_scaling,
MENU_ENUM_LABEL_VIDEO_CTX_SCALING,
MENU_ENUM_LABEL_VALUE_VIDEO_RGA_SCALING,
DEFAULT_VIDEO_CTX_SCALING,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_REINIT);
#endif
CONFIG_UINT(
list, list_info,
&settings->uints.video_rotation,
MENU_ENUM_LABEL_VIDEO_ROTATION,
MENU_ENUM_LABEL_VALUE_VIDEO_ROTATION,
0,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
menu_settings_list_current_add_range(list, list_info, 0, 3, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_video_rotation;
CONFIG_UINT(
list, list_info,
&settings->uints.screen_orientation,
MENU_ENUM_LABEL_SCREEN_ORIENTATION,
MENU_ENUM_LABEL_VALUE_SCREEN_ORIENTATION,
0,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
menu_settings_list_current_add_range(list, list_info, 0, 3, 1, true, true);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_screen_orientation;
END_SUB_GROUP(list, list_info, parent_group);
if (video_driver_supports_hdr())
{
START_SUB_GROUP(list, list_info, "HDR", &group_info, &subgroup_info, parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_VIDEO_HDR_SETTINGS,
MENU_ENUM_LABEL_VALUE_VIDEO_HDR_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
CONFIG_BOOL(
list, list_info,
&settings->bools.video_hdr_enable,
MENU_ENUM_LABEL_VIDEO_HDR_ENABLE,
MENU_ENUM_LABEL_VALUE_VIDEO_HDR_ENABLE,
DEFAULT_VIDEO_HDR_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].action_ok = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = setting_bool_action_right_with_refresh;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(
list,
list_info,
CMD_EVENT_VIDEO_APPLY_STATE_CHANGES);
/* if (settings->bools.video_hdr_enable) */
{
CONFIG_FLOAT(
list, list_info,
&settings->floats.video_hdr_max_nits,
MENU_ENUM_LABEL_VIDEO_HDR_MAX_NITS,
MENU_ENUM_LABEL_VALUE_VIDEO_HDR_MAX_NITS,
DEFAULT_VIDEO_HDR_MAX_NITS,
"%.1fx",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0.0, 10000.0, 10.0, true, true);
CONFIG_FLOAT(
list, list_info,
&settings->floats.video_hdr_paper_white_nits,
MENU_ENUM_LABEL_VIDEO_HDR_PAPER_WHITE_NITS,
MENU_ENUM_LABEL_VALUE_VIDEO_HDR_PAPER_WHITE_NITS,
DEFAULT_VIDEO_HDR_PAPER_WHITE_NITS,
"%.1fx",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0.0, 10000.0, 10.0, true, true);
CONFIG_FLOAT(
list, list_info,
&settings->floats.video_hdr_display_contrast,
MENU_ENUM_LABEL_VIDEO_HDR_CONTRAST,
MENU_ENUM_LABEL_VALUE_VIDEO_HDR_CONTRAST,
DEFAULT_VIDEO_HDR_CONTRAST,
"%.2fx",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0.0, VIDEO_HDR_MAX_CONTRAST, 0.1, true, true);
CONFIG_BOOL(
list, list_info,
&settings->bools.video_hdr_expand_gamut,
MENU_ENUM_LABEL_VIDEO_HDR_EXPAND_GAMUT,
MENU_ENUM_LABEL_VALUE_VIDEO_HDR_EXPAND_GAMUT,
DEFAULT_VIDEO_HDR_EXPAND_GAMUT,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].action_ok = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = setting_bool_action_right_with_refresh;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(
list,
list_info,
CMD_EVENT_VIDEO_APPLY_STATE_CHANGES);
}
END_SUB_GROUP(list, list_info, parent_group);
}
START_SUB_GROUP(
list,
list_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_AUDIO_SYNC),
&group_info,
&subgroup_info,
parent_group);
if (frontend_driver_can_set_screen_brightness())
{
CONFIG_UINT(
list, list_info,
&settings->uints.screen_brightness,
MENU_ENUM_LABEL_BRIGHTNESS_CONTROL,
MENU_ENUM_LABEL_VALUE_BRIGHTNESS_CONTROL,
DEFAULT_SCREEN_BRIGHTNESS,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint_special;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_percentage;
menu_settings_list_current_add_range(list, list_info, 5, 100, 5, true, true);
}
#if defined(HAVE_THREADS) && !defined(__PSL1GHT__) && !defined(__PS3__)
CONFIG_BOOL(
list, list_info,
video_driver_get_threaded(),
MENU_ENUM_LABEL_VIDEO_THREADED,
MENU_ENUM_LABEL_VALUE_VIDEO_THREADED,
DEFAULT_VIDEO_THREADED,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_CMD_APPLY_AUTO
);
(*list)[list_info->index - 1].action_ok = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = setting_bool_action_right_with_refresh;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_REINIT);
#endif
CONFIG_BOOL(
list, list_info,
&settings->bools.video_vsync,
MENU_ENUM_LABEL_VIDEO_VSYNC,
MENU_ENUM_LABEL_VALUE_VIDEO_VSYNC,
DEFAULT_VSYNC,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
(*list)[list_info->index - 1].action_ok = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = setting_bool_action_right_with_refresh;
CONFIG_UINT(
list, list_info,
&settings->uints.video_swap_interval,
MENU_ENUM_LABEL_VIDEO_SWAP_INTERVAL,
MENU_ENUM_LABEL_VALUE_VIDEO_SWAP_INTERVAL,
DEFAULT_SWAP_INTERVAL,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_video_swap_interval;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_REINIT);
menu_settings_list_current_add_range(list, list_info, 0, 4, 1, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_CMD_APPLY_AUTO);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_UINT(
list, list_info,
&settings->uints.video_shader_subframes,
MENU_ENUM_LABEL_VIDEO_SHADER_SUBFRAMES,
MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_SUBFRAMES,
DEFAULT_SHADER_SUBFRAMES,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_shader_subframes;
(*list)[list_info->index - 1].offset_by = 1;
menu_settings_list_current_add_range(list, list_info, 1, 16, 1, true, true);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_REINIT);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_CMD_APPLY_AUTO);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_BOOL(
list, list_info,
&settings->bools.video_scan_subframes,
MENU_ENUM_LABEL_VIDEO_SCAN_SUBFRAMES,
MENU_ENUM_LABEL_VALUE_VIDEO_SCAN_SUBFRAMES,
DEFAULT_SCAN_SUBFRAMES,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].action_ok = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = setting_bool_action_right_with_refresh;
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_CMD_APPLY_AUTO);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_REINIT);
CONFIG_UINT(
list, list_info,
&settings->uints.video_max_swapchain_images,
MENU_ENUM_LABEL_VIDEO_MAX_SWAPCHAIN_IMAGES,
MENU_ENUM_LABEL_VALUE_VIDEO_MAX_SWAPCHAIN_IMAGES,
DEFAULT_MAX_SWAPCHAIN_IMAGES,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].offset_by = 2;
menu_settings_list_current_add_range(list, list_info, (*list)[list_info->index - 1].offset_by, 4, 1, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_CMD_APPLY_AUTO);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_REINIT);
CONFIG_BOOL(
list, list_info,
&settings->bools.video_waitable_swapchains,
MENU_ENUM_LABEL_VIDEO_WAITABLE_SWAPCHAINS,
MENU_ENUM_LABEL_VALUE_VIDEO_WAITABLE_SWAPCHAINS,
DEFAULT_WAITABLE_SWAPCHAINS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].action_ok = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = setting_bool_action_right_with_refresh;
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_CMD_APPLY_AUTO);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_REINIT);
CONFIG_UINT(
list, list_info,
&settings->uints.video_max_frame_latency,
MENU_ENUM_LABEL_VIDEO_MAX_FRAME_LATENCY,
MENU_ENUM_LABEL_VALUE_VIDEO_MAX_FRAME_LATENCY,
DEFAULT_MAX_FRAME_LATENCY,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].offset_by = 0;
menu_settings_list_current_add_range(list, list_info, (*list)[list_info->index - 1].offset_by, MAXIMUM_MAX_FRAME_LATENCY, 1, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_CMD_APPLY_AUTO);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_REINIT);
CONFIG_BOOL(
list, list_info,
&settings->bools.video_hard_sync,
MENU_ENUM_LABEL_VIDEO_HARD_SYNC,
MENU_ENUM_LABEL_VALUE_VIDEO_HARD_SYNC,
DEFAULT_HARD_SYNC,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].action_ok = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = setting_bool_action_right_with_refresh;
CONFIG_UINT(
list, list_info,
&settings->uints.video_hard_sync_frames,
MENU_ENUM_LABEL_VIDEO_HARD_SYNC_FRAMES,
MENU_ENUM_LABEL_VALUE_VIDEO_HARD_SYNC_FRAMES,
DEFAULT_HARD_SYNC_FRAMES,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0, 3, 1, true, true);
if (video_driver_test_all_flags(GFX_CTX_FLAGS_ADAPTIVE_VSYNC))
{
CONFIG_BOOL(
list, list_info,
&settings->bools.video_adaptive_vsync,
MENU_ENUM_LABEL_VIDEO_ADAPTIVE_VSYNC,
MENU_ENUM_LABEL_VALUE_VIDEO_ADAPTIVE_VSYNC,
DEFAULT_ADAPTIVE_VSYNC,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
}
CONFIG_UINT(
list, list_info,
&settings->uints.video_frame_delay,
MENU_ENUM_LABEL_VIDEO_FRAME_DELAY,
MENU_ENUM_LABEL_VALUE_VIDEO_FRAME_DELAY,
DEFAULT_FRAME_DELAY,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0, MAXIMUM_FRAME_DELAY, 1, true, true);
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_video_frame_delay;
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_BOOL(
list, list_info,
&settings->bools.video_frame_delay_auto,
MENU_ENUM_LABEL_VIDEO_FRAME_DELAY_AUTO,
MENU_ENUM_LABEL_VALUE_VIDEO_FRAME_DELAY_AUTO,
DEFAULT_FRAME_DELAY_AUTO,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
/* Unlike all other shader-related menu entries
* (which appear in the shaders quick menu, and
* are thus hidden automatically on platforms
* without shader support), VIDEO_SHADER_DELAY
* is shown in 'Settings > Video'. It therefore
* requires an explicit guard to prevent display
* on unsupported platforms */
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
if (video_shader_any_supported())
{
CONFIG_UINT(
list, list_info,
&settings->uints.video_shader_delay,
MENU_ENUM_LABEL_VIDEO_SHADER_DELAY,
MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_DELAY,
DEFAULT_SHADER_DELAY,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0, 0, 1, true, false);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
}
#endif
CONFIG_BOOL(
list, list_info,
&settings->bools.video_shader_watch_files,
MENU_ENUM_LABEL_SHADER_WATCH_FOR_CHANGES,
MENU_ENUM_LABEL_VALUE_SHADER_WATCH_FOR_CHANGES,
DEFAULT_VIDEO_SHADER_WATCH_FILES,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.video_shader_remember_last_dir,
MENU_ENUM_LABEL_VIDEO_SHADER_REMEMBER_LAST_DIR,
MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_REMEMBER_LAST_DIR,
DEFAULT_VIDEO_SHADER_REMEMBER_LAST_DIR,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
#if !defined(RARCH_MOBILE)
{
#if defined(HAVE_STEAM) && defined(HAVE_MIST)
bool on_deck = false;
mist_steam_utils_is_steam_running_on_steam_deck(&on_deck);
/* We want to not expose Black Frame Insertion on Steam Deck
* for safety reasons */
if (!on_deck && video_driver_test_all_flags(GFX_CTX_FLAGS_BLACK_FRAME_INSERTION))
#else
if (video_driver_test_all_flags(GFX_CTX_FLAGS_BLACK_FRAME_INSERTION))
#endif
{
CONFIG_UINT(
list, list_info,
&settings->uints.video_black_frame_insertion,
MENU_ENUM_LABEL_VIDEO_BLACK_FRAME_INSERTION,
MENU_ENUM_LABEL_VALUE_VIDEO_BLACK_FRAME_INSERTION,
DEFAULT_BLACK_FRAME_INSERTION,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_black_frame_insertion;
menu_settings_list_current_add_range(list, list_info, 0, 15, 1, true, true);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_REINIT);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_CMD_APPLY_AUTO);
CONFIG_UINT(
list, list_info,
&settings->uints.video_bfi_dark_frames,
MENU_ENUM_LABEL_VIDEO_BFI_DARK_FRAMES,
MENU_ENUM_LABEL_VALUE_VIDEO_BFI_DARK_FRAMES,
DEFAULT_BFI_DARK_FRAMES,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].offset_by = 1;
menu_settings_list_current_add_range(list, list_info, 1, 15, 1, true, true);
}
}
#endif
END_SUB_GROUP(list, list_info, parent_group);
START_SUB_GROUP(
list,
list_info,
"Miscellaneous",
&group_info,
&subgroup_info,
parent_group);
CONFIG_BOOL(
list, list_info,
&settings->bools.video_gpu_screenshot,
MENU_ENUM_LABEL_VIDEO_GPU_SCREENSHOT,
MENU_ENUM_LABEL_VALUE_VIDEO_GPU_SCREENSHOT,
DEFAULT_GPU_SCREENSHOT,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
CONFIG_BOOL(
list, list_info,
&settings->bools.video_crop_overscan,
MENU_ENUM_LABEL_VIDEO_CROP_OVERSCAN,
MENU_ENUM_LABEL_VALUE_VIDEO_CROP_OVERSCAN,
DEFAULT_CROP_OVERSCAN,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_PATH(
list, list_info,
settings->paths.path_softfilter_plugin,
sizeof(settings->paths.path_softfilter_plugin),
MENU_ENUM_LABEL_VIDEO_FILTER,
MENU_ENUM_LABEL_VALUE_VIDEO_FILTER,
settings->paths.directory_video_filter,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_video_filter;
MENU_SETTINGS_LIST_CURRENT_ADD_VALUES(list, list_info, "filt");
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_REINIT);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
}
break;
case SETTINGS_LIST_CRT_SWITCHRES:
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_CRT_SWITCHRES_SETTINGS), parent_group);
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_IDX_PTR(list, list_info, MENU_ENUM_LABEL_CRT_SWITCHRES_SETTINGS);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
CONFIG_UINT(
list, list_info,
&settings->uints.crt_switch_resolution,
MENU_ENUM_LABEL_CRT_SWITCH_RESOLUTION,
MENU_ENUM_LABEL_VALUE_CRT_SWITCH_RESOLUTION,
DEFAULT_CRT_SWITCH_RESOLUTION,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_crt_switch_resolutions;
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
menu_settings_list_current_add_range(list, list_info, CRT_SWITCH_NONE, CRT_SWITCH_INI, 1.0, true, true);
CONFIG_UINT(
list, list_info,
&settings->uints.crt_switch_resolution_super,
MENU_ENUM_LABEL_CRT_SWITCH_RESOLUTION_SUPER,
MENU_ENUM_LABEL_VALUE_CRT_SWITCH_RESOLUTION_SUPER,
DEFAULT_CRT_SWITCH_RESOLUTION_SUPER,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
(*list)[list_info->index - 1].action_left = &setting_uint_action_left_crt_switch_resolution_super;
(*list)[list_info->index - 1].action_right = &setting_uint_action_right_crt_switch_resolution_super;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_crt_switch_resolution_super;
CONFIG_INT(
list, list_info,
&settings->ints.crt_switch_center_adjust,
MENU_ENUM_LABEL_CRT_SWITCH_X_AXIS_CENTERING,
MENU_ENUM_LABEL_VALUE_CRT_SWITCH_X_AXIS_CENTERING,
DEFAULT_CRT_SWITCH_CENTER_ADJUST,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_SPINBOX;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].offset_by = -3;
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
menu_settings_list_current_add_range(list, list_info, -3, 4, 1.0, true, true);
CONFIG_INT(
list, list_info,
&settings->ints.crt_switch_porch_adjust,
MENU_ENUM_LABEL_CRT_SWITCH_PORCH_ADJUST,
MENU_ENUM_LABEL_VALUE_CRT_SWITCH_PORCH_ADJUST,
DEFAULT_CRT_SWITCH_PORCH_ADJUST,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_SPINBOX;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].offset_by = 0;
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
menu_settings_list_current_add_range(list, list_info, -20, 20, 1.0, true, true);
CONFIG_BOOL(
list, list_info,
&settings->bools.crt_switch_custom_refresh_enable,
MENU_ENUM_LABEL_CRT_SWITCH_RESOLUTION_USE_CUSTOM_REFRESH_RATE,
MENU_ENUM_LABEL_VALUE_CRT_SWITCH_RESOLUTION_USE_CUSTOM_REFRESH_RATE,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.crt_switch_hires_menu,
MENU_ENUM_LABEL_CRT_SWITCH_HIRES_MENU,
MENU_ENUM_LABEL_VALUE_CRT_SWITCH_HIRES_MENU,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
case SETTINGS_LIST_MENU_SOUNDS:
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_MENU_SOUNDS),
parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_AUDIO_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
CONFIG_BOOL(
list, list_info,
&settings->bools.audio_enable_menu,
MENU_ENUM_LABEL_AUDIO_ENABLE_MENU,
MENU_ENUM_LABEL_VALUE_AUDIO_ENABLE_MENU,
DEFAULT_AUDIO_ENABLE_MENU,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.audio_enable_menu_ok,
MENU_ENUM_LABEL_MENU_SOUND_OK,
MENU_ENUM_LABEL_VALUE_MENU_SOUND_OK,
DEFAULT_AUDIO_ENABLE_MENU_OK,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.audio_enable_menu_cancel,
MENU_ENUM_LABEL_MENU_SOUND_CANCEL,
MENU_ENUM_LABEL_VALUE_MENU_SOUND_CANCEL,
DEFAULT_AUDIO_ENABLE_MENU_CANCEL,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.audio_enable_menu_notice,
MENU_ENUM_LABEL_MENU_SOUND_NOTICE,
MENU_ENUM_LABEL_VALUE_MENU_SOUND_NOTICE,
DEFAULT_AUDIO_ENABLE_MENU_NOTICE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.audio_enable_menu_bgm,
MENU_ENUM_LABEL_MENU_SOUND_BGM,
MENU_ENUM_LABEL_VALUE_MENU_SOUND_BGM,
DEFAULT_AUDIO_ENABLE_MENU_BGM,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.audio_enable_menu_scroll,
MENU_ENUM_LABEL_MENU_SOUND_SCROLL,
MENU_ENUM_LABEL_VALUE_MENU_SOUND_SCROLL,
DEFAULT_AUDIO_ENABLE_MENU_SCROLL,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
case SETTINGS_LIST_AUDIO:
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_AUDIO_SETTINGS), parent_group);
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_IDX_PTR(list, list_info, MENU_ENUM_LABEL_AUDIO_SETTINGS);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
CONFIG_BOOL(
list, list_info,
&settings->bools.audio_enable,
MENU_ENUM_LABEL_AUDIO_ENABLE,
MENU_ENUM_LABEL_VALUE_AUDIO_ENABLE,
DEFAULT_AUDIO_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_AUDIO_REINIT);
CONFIG_BOOL(
list, list_info,
audio_get_bool_ptr(AUDIO_ACTION_MUTE_ENABLE),
MENU_ENUM_LABEL_AUDIO_MUTE,
MENU_ENUM_LABEL_VALUE_AUDIO_MUTE,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
#ifdef HAVE_AUDIOMIXER
CONFIG_BOOL(
list, list_info,
audio_get_bool_ptr(AUDIO_ACTION_MIXER_MUTE_ENABLE),
MENU_ENUM_LABEL_AUDIO_MIXER_MUTE,
MENU_ENUM_LABEL_VALUE_AUDIO_MIXER_MUTE,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_LAKKA_ADVANCED
);
#endif
#if TARGET_OS_IOS
CONFIG_BOOL(
list, list_info,
&settings->bools.audio_respect_silent_mode,
MENU_ENUM_LABEL_AUDIO_RESPECT_SILENT_MODE,
MENU_ENUM_LABEL_VALUE_AUDIO_RESPECT_SILENT_MODE,
DEFAULT_AUDIO_RESPECT_SILENT_MODE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
#endif
CONFIG_BOOL(
list, list_info,
&settings->bools.audio_fastforward_mute,
MENU_ENUM_LABEL_AUDIO_FASTFORWARD_MUTE,
MENU_ENUM_LABEL_VALUE_AUDIO_FASTFORWARD_MUTE,
DEFAULT_AUDIO_FASTFORWARD_MUTE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.audio_fastforward_speedup,
MENU_ENUM_LABEL_AUDIO_FASTFORWARD_SPEEDUP,
MENU_ENUM_LABEL_VALUE_AUDIO_FASTFORWARD_SPEEDUP,
DEFAULT_AUDIO_FASTFORWARD_SPEEDUP,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_FLOAT(
list, list_info,
&settings->floats.audio_volume,
MENU_ENUM_LABEL_AUDIO_VOLUME,
MENU_ENUM_LABEL_VALUE_AUDIO_VOLUME,
DEFAULT_AUDIO_VOLUME,
"%.1f",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, -80, 12, 1.0, true, true);
#ifdef HAVE_AUDIOMIXER
CONFIG_FLOAT(
list, list_info,
&settings->floats.audio_mixer_volume,
MENU_ENUM_LABEL_AUDIO_MIXER_VOLUME,
MENU_ENUM_LABEL_VALUE_AUDIO_MIXER_VOLUME,
DEFAULT_AUDIO_MIXER_VOLUME,
"%.1f",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, -80, 12, 1.0, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
#endif
END_SUB_GROUP(list, list_info, parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_SETTINGS);
START_SUB_GROUP(
list,
list_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_AUDIO_SYNC),
&group_info,
&subgroup_info,
parent_group);
CONFIG_BOOL(
list, list_info,
&settings->bools.audio_sync,
MENU_ENUM_LABEL_AUDIO_SYNC,
MENU_ENUM_LABEL_VALUE_AUDIO_SYNC,
DEFAULT_AUDIO_SYNC,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_AUDIO_REINIT);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_UINT(
list, list_info,
&settings->uints.audio_latency,
MENU_ENUM_LABEL_AUDIO_LATENCY,
MENU_ENUM_LABEL_VALUE_AUDIO_LATENCY,
g_defaults.settings_out_latency ?
g_defaults.settings_out_latency : DEFAULT_OUT_LATENCY,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0, 512, 1.0, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
#ifdef HAVE_MICROPHONE
CONFIG_UINT(
list, list_info,
&settings->uints.microphone_latency,
MENU_ENUM_LABEL_MICROPHONE_LATENCY,
MENU_ENUM_LABEL_VALUE_MICROPHONE_LATENCY,
g_defaults.settings_in_latency ?
g_defaults.settings_in_latency : DEFAULT_IN_LATENCY,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0, 512, 1.0, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
#endif
CONFIG_UINT(
list, list_info,
&settings->uints.audio_resampler_quality,
MENU_ENUM_LABEL_AUDIO_RESAMPLER_QUALITY,
MENU_ENUM_LABEL_VALUE_AUDIO_RESAMPLER_QUALITY,
DEFAULT_AUDIO_RESAMPLER_QUALITY_LEVEL,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_audio_resampler_quality;
menu_settings_list_current_add_range(list, list_info, RESAMPLER_QUALITY_DONTCARE, RESAMPLER_QUALITY_HIGHEST, 1.0, true, true);
CONFIG_FLOAT(
list, list_info,
audio_get_float_ptr(AUDIO_ACTION_RATE_CONTROL_DELTA),
MENU_ENUM_LABEL_AUDIO_RATE_CONTROL_DELTA,
MENU_ENUM_LABEL_VALUE_AUDIO_RATE_CONTROL_DELTA,
DEFAULT_RATE_CONTROL_DELTA,
"%.3f",
&group_info,
&subgroup_info,
parent_group,
write_handler_audio_rate_control_delta,
read_handler_audio_rate_control_delta);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(
list,
list_info,
0.0,
0.020,
0.001,
true,
true);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_AUDIO_REINIT);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
CONFIG_FLOAT(
list, list_info,
&settings->floats.audio_max_timing_skew,
MENU_ENUM_LABEL_AUDIO_MAX_TIMING_SKEW,
MENU_ENUM_LABEL_VALUE_AUDIO_MAX_TIMING_SKEW,
DEFAULT_MAX_TIMING_SKEW,
"%.3f",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(
list,
list_info,
0.0,
0.5,
0.01,
true,
true);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_AUDIO_REINIT);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
#ifdef RARCH_MOBILE
CONFIG_UINT(
list, list_info,
&settings->uints.audio_block_frames,
MENU_ENUM_LABEL_AUDIO_BLOCK_FRAMES,
MENU_ENUM_LABEL_VALUE_AUDIO_BLOCK_FRAMES,
0,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
#ifdef HAVE_MICROPHONE
CONFIG_UINT(
list, list_info,
&settings->uints.microphone_block_frames,
MENU_ENUM_LABEL_MICROPHONE_BLOCK_FRAMES,
MENU_ENUM_LABEL_VALUE_MICROPHONE_BLOCK_FRAMES,
0,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
#endif
#endif
END_SUB_GROUP(list, list_info, parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_SETTINGS);
START_SUB_GROUP(
list,
list_info,
"Miscellaneous",
&group_info,
&subgroup_info,
parent_group);
#if !defined(RARCH_CONSOLE)
CONFIG_STRING(
list, list_info,
settings->arrays.audio_device,
sizeof(settings->arrays.audio_device),
MENU_ENUM_LABEL_AUDIO_DEVICE,
MENU_ENUM_LABEL_VALUE_AUDIO_DEVICE,
"",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = &setting_string_action_start_audio_device;
(*list)[list_info->index - 1].action_left = &setting_string_action_left_audio_device;
(*list)[list_info->index - 1].action_right = &setting_string_action_right_audio_device;
(*list)[list_info->index - 1].action_ok = &setting_string_action_ok_audio_device;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_string_audio_device;
#ifdef HAVE_MICROPHONE
CONFIG_STRING(
list, list_info,
settings->arrays.microphone_device,
sizeof(settings->arrays.microphone_device),
MENU_ENUM_LABEL_MICROPHONE_DEVICE,
MENU_ENUM_LABEL_VALUE_MICROPHONE_DEVICE,
"",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_STRING_LINE_EDIT;
(*list)[list_info->index - 1].action_start = setting_string_action_start_microphone_device;
(*list)[list_info->index - 1].action_left = &setting_string_action_left_microphone_device;
(*list)[list_info->index - 1].action_right = &setting_string_action_right_microphone_device;
(*list)[list_info->index - 1].action_ok = &setting_string_action_ok_microphone_device;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_string_audio_device;
#endif
#endif
CONFIG_UINT(
list, list_info,
&settings->uints.audio_output_sample_rate,
MENU_ENUM_LABEL_AUDIO_OUTPUT_RATE,
MENU_ENUM_LABEL_VALUE_AUDIO_OUTPUT_RATE,
DEFAULT_OUTPUT_RATE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint_special;
menu_settings_list_current_add_range(list, list_info, 1000, 192000, 100.0, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
#ifdef HAVE_MICROPHONE
CONFIG_UINT(
list, list_info,
&settings->uints.microphone_sample_rate,
MENU_ENUM_LABEL_MICROPHONE_INPUT_RATE,
MENU_ENUM_LABEL_VALUE_MICROPHONE_INPUT_RATE,
DEFAULT_INPUT_RATE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint_special;
menu_settings_list_current_add_range(list, list_info, 1000, 192000, 100.0, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
#endif
CONFIG_PATH(
list, list_info,
settings->paths.path_audio_dsp_plugin,
sizeof(settings->paths.path_audio_dsp_plugin),
MENU_ENUM_LABEL_AUDIO_DSP_PLUGIN,
MENU_ENUM_LABEL_VALUE_AUDIO_DSP_PLUGIN,
settings->paths.directory_audio_filter,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
MENU_SETTINGS_LIST_CURRENT_ADD_VALUES(list, list_info, "dsp");
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_DSP_FILTER_INIT);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
#ifdef HAVE_WASAPI
if (string_is_equal(settings->arrays.audio_driver, "wasapi"))
{
CONFIG_BOOL(
list, list_info,
&settings->bools.audio_wasapi_exclusive_mode,
MENU_ENUM_LABEL_AUDIO_WASAPI_EXCLUSIVE_MODE,
MENU_ENUM_LABEL_VALUE_AUDIO_WASAPI_EXCLUSIVE_MODE,
DEFAULT_WASAPI_EXCLUSIVE_MODE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.audio_wasapi_float_format,
MENU_ENUM_LABEL_AUDIO_WASAPI_FLOAT_FORMAT,
MENU_ENUM_LABEL_VALUE_AUDIO_WASAPI_FLOAT_FORMAT,
DEFAULT_WASAPI_FLOAT_FORMAT,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_UINT(
list, list_info,
&settings->uints.audio_wasapi_sh_buffer_length,
MENU_ENUM_LABEL_AUDIO_WASAPI_SH_BUFFER_LENGTH,
MENU_ENUM_LABEL_VALUE_AUDIO_WASAPI_SH_BUFFER_LENGTH,
DEFAULT_WASAPI_SH_BUFFER_LENGTH,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint_special;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_audio_wasapi_sh_buffer_length;
menu_settings_list_current_add_range(list, list_info, 0, 32.0f * 200, 32.0f, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
}
#endif
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
#ifdef HAVE_MICROPHONE
case SETTINGS_LIST_MICROPHONE:
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_MICROPHONE_SETTINGS), parent_group);
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_IDX_PTR(list, list_info, MENU_ENUM_LABEL_MICROPHONE_SETTINGS);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
CONFIG_BOOL(
list, list_info,
&settings->bools.microphone_enable,
MENU_ENUM_LABEL_MICROPHONE_ENABLE,
MENU_ENUM_LABEL_VALUE_MICROPHONE_ENABLE,
DEFAULT_AUDIO_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
END_SUB_GROUP(list, list_info, parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_SETTINGS);
CONFIG_UINT(
list, list_info,
&settings->uints.microphone_latency,
MENU_ENUM_LABEL_MICROPHONE_LATENCY,
MENU_ENUM_LABEL_VALUE_MICROPHONE_LATENCY,
g_defaults.settings_in_latency ?
g_defaults.settings_in_latency : DEFAULT_IN_LATENCY,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0, 512, 1.0, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
#ifdef RARCH_MOBILE
CONFIG_UINT(
list, list_info,
&settings->uints.microphone_block_frames,
MENU_ENUM_LABEL_MICROPHONE_BLOCK_FRAMES,
MENU_ENUM_LABEL_VALUE_MICROPHONE_BLOCK_FRAMES,
0,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
#endif
END_SUB_GROUP(list, list_info, parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_SETTINGS);
START_SUB_GROUP(
list,
list_info,
"Miscellaneous",
&group_info,
&subgroup_info,
parent_group);
#if !defined(RARCH_CONSOLE)
CONFIG_STRING(
list, list_info,
settings->arrays.microphone_device,
sizeof(settings->arrays.microphone_device),
MENU_ENUM_LABEL_MICROPHONE_DEVICE,
MENU_ENUM_LABEL_VALUE_MICROPHONE_DEVICE,
"",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_STRING_LINE_EDIT;
(*list)[list_info->index - 1].action_start = setting_generic_action_start_default;
(*list)[list_info->index - 1].action_left = &setting_string_action_left_microphone_device;
(*list)[list_info->index - 1].action_right = &setting_string_action_right_microphone_device;
(*list)[list_info->index - 1].action_ok = &setting_string_action_ok_microphone_device;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_string_audio_device;
#endif
CONFIG_UINT(
list, list_info,
&settings->uints.microphone_sample_rate,
MENU_ENUM_LABEL_MICROPHONE_INPUT_RATE,
MENU_ENUM_LABEL_VALUE_MICROPHONE_INPUT_RATE,
DEFAULT_INPUT_RATE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint_special;
menu_settings_list_current_add_range(list, list_info, 1000, 192000, 100.0, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
CONFIG_UINT(
list, list_info,
&settings->uints.microphone_resampler_quality,
MENU_ENUM_LABEL_MICROPHONE_RESAMPLER_QUALITY,
MENU_ENUM_LABEL_VALUE_MICROPHONE_RESAMPLER_QUALITY,
DEFAULT_AUDIO_RESAMPLER_QUALITY_LEVEL,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_audio_resampler_quality;
menu_settings_list_current_add_range(list, list_info, RESAMPLER_QUALITY_DONTCARE, RESAMPLER_QUALITY_HIGHEST, 1.0, true, true);
#ifdef HAVE_WASAPI
if (string_is_equal(settings->arrays.microphone_driver, "wasapi"))
{
CONFIG_BOOL(
list, list_info,
&settings->bools.microphone_wasapi_exclusive_mode,
MENU_ENUM_LABEL_MICROPHONE_WASAPI_EXCLUSIVE_MODE,
MENU_ENUM_LABEL_VALUE_MICROPHONE_WASAPI_EXCLUSIVE_MODE,
DEFAULT_WASAPI_EXCLUSIVE_MODE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.microphone_wasapi_float_format,
MENU_ENUM_LABEL_MICROPHONE_WASAPI_FLOAT_FORMAT,
MENU_ENUM_LABEL_VALUE_MICROPHONE_WASAPI_FLOAT_FORMAT,
DEFAULT_WASAPI_FLOAT_FORMAT,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_UINT(
list, list_info,
&settings->uints.microphone_wasapi_sh_buffer_length,
MENU_ENUM_LABEL_MICROPHONE_WASAPI_SH_BUFFER_LENGTH,
MENU_ENUM_LABEL_VALUE_MICROPHONE_WASAPI_SH_BUFFER_LENGTH,
DEFAULT_WASAPI_MICROPHONE_SH_BUFFER_LENGTH,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint_special;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_microphone_wasapi_sh_buffer_length;
menu_settings_list_current_add_range(list, list_info, 0, 32.0f * 200, 32.0f, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
}
#endif
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
#endif
case SETTINGS_LIST_INPUT:
{
unsigned user;
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_INPUT_SETTINGS_BEGIN),
parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
CONFIG_UINT(
list, list_info,
&settings->uints.input_max_users,
MENU_ENUM_LABEL_INPUT_MAX_USERS,
MENU_ENUM_LABEL_VALUE_INPUT_MAX_USERS,
DEFAULT_INPUT_MAX_USERS,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].action_left = &setting_uint_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_uint_action_right_with_refresh;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_max_users;
(*list)[list_info->index - 1].offset_by = 1;
menu_settings_list_current_add_range(list, list_info, 1, MAX_USERS, 1, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_unified_controls,
MENU_ENUM_LABEL_INPUT_UNIFIED_MENU_CONTROLS,
MENU_ENUM_LABEL_VALUE_INPUT_UNIFIED_MENU_CONTROLS,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_disable_info_button,
MENU_ENUM_LABEL_INPUT_DISABLE_INFO_BUTTON,
MENU_ENUM_LABEL_VALUE_INPUT_DISABLE_INFO_BUTTON,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED
);
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_disable_search_button,
MENU_ENUM_LABEL_INPUT_DISABLE_SEARCH_BUTTON,
MENU_ENUM_LABEL_VALUE_INPUT_DISABLE_SEARCH_BUTTON,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED
);
CONFIG_BOOL(
list, list_info,
&settings->bools.quit_press_twice,
MENU_ENUM_LABEL_QUIT_PRESS_TWICE,
MENU_ENUM_LABEL_VALUE_QUIT_PRESS_TWICE,
DEFAULT_QUIT_PRESS_TWICE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.vibrate_on_keypress,
MENU_ENUM_LABEL_VIBRATE_ON_KEYPRESS,
MENU_ENUM_LABEL_VALUE_VIBRATE_ON_KEYPRESS,
DEFAULT_VIBRATE_ON_KEYPRESS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.enable_device_vibration,
MENU_ENUM_LABEL_ENABLE_DEVICE_VIBRATION,
MENU_ENUM_LABEL_VALUE_ENABLE_DEVICE_VIBRATION,
DEFAULT_ENABLE_DEVICE_VIBRATION,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_UINT(
list, list_info,
&settings->uints.input_rumble_gain,
MENU_ENUM_LABEL_INPUT_RUMBLE_GAIN,
MENU_ENUM_LABEL_VALUE_INPUT_RUMBLE_GAIN,
DEFAULT_RUMBLE_GAIN,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint_special;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_percentage;
menu_settings_list_current_add_range(list, list_info, 0, 100, 5, true, true);
CONFIG_UINT(
list, list_info,
&settings->uints.input_poll_type_behavior,
MENU_ENUM_LABEL_INPUT_POLL_TYPE_BEHAVIOR,
MENU_ENUM_LABEL_VALUE_INPUT_POLL_TYPE_BEHAVIOR,
DEFAULT_INPUT_POLL_TYPE_BEHAVIOR,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_poll_type_behavior;
menu_settings_list_current_add_range(list, list_info, 0, 2, 1, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
#ifdef GEKKO
CONFIG_UINT(
list, list_info,
&settings->uints.input_mouse_scale,
MENU_ENUM_LABEL_INPUT_MOUSE_SCALE,
MENU_ENUM_LABEL_VALUE_INPUT_MOUSE_SCALE,
DEFAULT_MOUSE_SCALE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
menu_settings_list_current_add_range(list, list_info, 1, 4, 1, true, true);
#endif
CONFIG_UINT(
list, list_info,
&settings->uints.input_touch_scale,
MENU_ENUM_LABEL_INPUT_TOUCH_SCALE,
MENU_ENUM_LABEL_VALUE_INPUT_TOUCH_SCALE,
DEFAULT_TOUCH_SCALE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_input_touch_scale;
(*list)[list_info->index - 1].offset_by = 1;
menu_settings_list_current_add_range(list, list_info, 1, 4, 1, true, true);
#ifdef UDEV_TOUCH_SUPPORT
CONFIG_BOOL(
list, list_info,
&settings->bools.input_touch_vmouse_pointer,
MENU_ENUM_LABEL_INPUT_TOUCH_VMOUSE_POINTER,
MENU_ENUM_LABEL_VALUE_INPUT_TOUCH_VMOUSE_POINTER,
DEFAULT_INPUT_TOUCH_VMOUSE_POINTER,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.input_touch_vmouse_mouse,
MENU_ENUM_LABEL_INPUT_TOUCH_VMOUSE_MOUSE,
MENU_ENUM_LABEL_VALUE_INPUT_TOUCH_VMOUSE_MOUSE,
DEFAULT_INPUT_TOUCH_VMOUSE_MOUSE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.input_touch_vmouse_touchpad,
MENU_ENUM_LABEL_INPUT_TOUCH_VMOUSE_TOUCHPAD,
MENU_ENUM_LABEL_VALUE_INPUT_TOUCH_VMOUSE_TOUCHPAD,
DEFAULT_INPUT_TOUCH_VMOUSE_TOUCHPAD,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.input_touch_vmouse_trackball,
MENU_ENUM_LABEL_INPUT_TOUCH_VMOUSE_TRACKBALL,
MENU_ENUM_LABEL_VALUE_INPUT_TOUCH_VMOUSE_TRACKBALL,
DEFAULT_INPUT_TOUCH_VMOUSE_TRACKBALL,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.input_touch_vmouse_gesture,
MENU_ENUM_LABEL_INPUT_TOUCH_VMOUSE_GESTURE,
MENU_ENUM_LABEL_VALUE_INPUT_TOUCH_VMOUSE_GESTURE,
DEFAULT_INPUT_TOUCH_VMOUSE_GESTURE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
#endif
#ifdef VITA
CONFIG_BOOL(
list, list_info,
&settings->bools.input_backtouch_enable,
MENU_ENUM_LABEL_INPUT_TOUCH_ENABLE,
MENU_ENUM_LABEL_VALUE_INPUT_TOUCH_ENABLE,
DEFAULT_INPUT_BACKTOUCH_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.input_backtouch_toggle,
MENU_ENUM_LABEL_INPUT_PREFER_FRONT_TOUCH,
MENU_ENUM_LABEL_VALUE_INPUT_PREFER_FRONT_TOUCH,
DEFAULT_INPUT_BACKTOUCH_TOGGLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
#endif
#if TARGET_OS_IPHONE
CONFIG_BOOL(
list, list_info,
&settings->bools.input_keyboard_gamepad_enable,
MENU_ENUM_LABEL_INPUT_ICADE_ENABLE,
MENU_ENUM_LABEL_VALUE_INPUT_ICADE_ENABLE,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_UINT(
list, list_info,
&settings->uints.input_keyboard_gamepad_mapping_type,
MENU_ENUM_LABEL_INPUT_KEYBOARD_GAMEPAD_MAPPING_TYPE,
MENU_ENUM_LABEL_VALUE_INPUT_KEYBOARD_GAMEPAD_MAPPING_TYPE,
1,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_keyboard_gamepad_mapping_type;
menu_settings_list_current_add_range(list, list_info, 0, 3, 1, true, true);
CONFIG_BOOL(
list, list_info,
&settings->bools.input_small_keyboard_enable,
MENU_ENUM_LABEL_INPUT_SMALL_KEYBOARD_ENABLE,
MENU_ENUM_LABEL_VALUE_INPUT_SMALL_KEYBOARD_ENABLE,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
#endif
CONFIG_UINT(
list, list_info,
&settings->uints.input_menu_toggle_gamepad_combo,
MENU_ENUM_LABEL_INPUT_MENU_ENUM_TOGGLE_GAMEPAD_COMBO,
MENU_ENUM_LABEL_VALUE_INPUT_MENU_ENUM_TOGGLE_GAMEPAD_COMBO,
DEFAULT_MENU_TOGGLE_GAMEPAD_COMBO,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_gamepad_combo;
menu_settings_list_current_add_range(list, list_info, 0, (INPUT_COMBO_LAST-1), 1, true, true);
CONFIG_UINT(
list, list_info,
&settings->uints.input_quit_gamepad_combo,
MENU_ENUM_LABEL_INPUT_QUIT_GAMEPAD_COMBO,
MENU_ENUM_LABEL_VALUE_INPUT_QUIT_GAMEPAD_COMBO,
DEFAULT_QUIT_GAMEPAD_COMBO,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_gamepad_combo;
menu_settings_list_current_add_range(list, list_info, 0, (INPUT_COMBO_LAST-1), 1, true, true);
CONFIG_UINT(
list, list_info,
&settings->uints.input_hotkey_block_delay,
MENU_ENUM_LABEL_INPUT_HOTKEY_BLOCK_DELAY,
MENU_ENUM_LABEL_VALUE_INPUT_HOTKEY_BLOCK_DELAY,
DEFAULT_INPUT_HOTKEY_BLOCK_DELAY,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0, 600, 1, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
CONFIG_BOOL(
list, list_info,
&settings->bools.input_hotkey_device_merge,
MENU_ENUM_LABEL_INPUT_HOTKEY_DEVICE_MERGE,
MENU_ENUM_LABEL_VALUE_INPUT_HOTKEY_DEVICE_MERGE,
DEFAULT_INPUT_HOTKEY_DEVICE_MERGE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.input_menu_swap_ok_cancel_buttons,
MENU_ENUM_LABEL_MENU_INPUT_SWAP_OK_CANCEL,
MENU_ENUM_LABEL_VALUE_MENU_INPUT_SWAP_OK_CANCEL,
DEFAULT_MENU_SWAP_OK_CANCEL_BUTTONS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.input_menu_swap_scroll_buttons,
MENU_ENUM_LABEL_MENU_INPUT_SWAP_SCROLL,
MENU_ENUM_LABEL_VALUE_MENU_INPUT_SWAP_SCROLL,
DEFAULT_MENU_SWAP_SCROLL_BUTTONS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.input_all_users_control_menu,
MENU_ENUM_LABEL_INPUT_ALL_USERS_CONTROL_MENU,
MENU_ENUM_LABEL_VALUE_INPUT_ALL_USERS_CONTROL_MENU,
DEFAULT_ALL_USERS_CONTROL_MENU,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.input_remap_binds_enable,
MENU_ENUM_LABEL_INPUT_REMAP_BINDS_ENABLE,
MENU_ENUM_LABEL_VALUE_INPUT_REMAP_BINDS_ENABLE,
true,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED
);
CONFIG_BOOL(
list, list_info,
&settings->bools.input_autodetect_enable,
MENU_ENUM_LABEL_INPUT_AUTODETECT_ENABLE,
MENU_ENUM_LABEL_VALUE_INPUT_AUTODETECT_ENABLE,
DEFAULT_INPUT_AUTODETECT_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED
);
#if defined(HAVE_DINPUT) || defined(HAVE_WINRAWINPUT)
CONFIG_BOOL(
list, list_info,
&settings->bools.input_nowinkey_enable,
MENU_ENUM_LABEL_INPUT_NOWINKEY_ENABLE,
MENU_ENUM_LABEL_VALUE_INPUT_NOWINKEY_ENABLE,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
#endif
CONFIG_BOOL(
list, list_info,
&settings->bools.input_sensors_enable,
MENU_ENUM_LABEL_INPUT_SENSORS_ENABLE,
MENU_ENUM_LABEL_VALUE_INPUT_SENSORS_ENABLE,
DEFAULT_INPUT_SENSORS_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.input_auto_mouse_grab,
MENU_ENUM_LABEL_INPUT_AUTO_MOUSE_GRAB,
MENU_ENUM_LABEL_VALUE_INPUT_AUTO_MOUSE_GRAB,
DEFAULT_INPUT_AUTO_MOUSE_GRAB,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
#ifdef ANDROID
CONFIG_BOOL(
list, list_info,
&settings->bools.android_input_disconnect_workaround,
MENU_ENUM_LABEL_ANDROID_INPUT_DISCONNECT_WORKAROUND,
MENU_ENUM_LABEL_VALUE_ANDROID_INPUT_DISCONNECT_WORKAROUND,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
input_driver_state_t *st = input_state_get_ptr();
input_driver_t *current_input = st->current_driver;
if (string_is_equal(current_input->ident, "android"))
{
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_INPUT_SELECT_PHYSICAL_KEYBOARD,
MENU_ENUM_LABEL_VALUE_INPUT_SELECT_PHYSICAL_KEYBOARD,
&group_info,
&subgroup_info,
parent_group);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_select_physical_keyboard;
(*list)[list_info->index - 1].read_handler = &general_read_handler;
(*list)[list_info->index - 1].change_handler = &general_write_handler;
(*list)[list_info->index - 1].get_string_representation = &setting_get_string_representation_android_physical_keyboard;
(*list)[list_info->index - 1].default_value.string = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NONE);
}
#endif
CONFIG_UINT(
list, list_info,
&settings->uints.input_auto_game_focus,
MENU_ENUM_LABEL_INPUT_AUTO_GAME_FOCUS,
MENU_ENUM_LABEL_VALUE_INPUT_AUTO_GAME_FOCUS,
DEFAULT_INPUT_AUTO_GAME_FOCUS,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_input_auto_game_focus;
menu_settings_list_current_add_range(list, list_info, 0, AUTO_GAME_FOCUS_LAST-1, 1, true, true);
CONFIG_BOOL(
list, list_info,
&settings->bools.pause_on_disconnect,
MENU_ENUM_LABEL_PAUSE_ON_DISCONNECT,
MENU_ENUM_LABEL_VALUE_PAUSE_ON_DISCONNECT,
DEFAULT_PAUSE_ON_DISCONNECT,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#if 0
CONFIG_BOOL(
list, list_info,
&settings->bools.input_descriptor_label_show,
MENU_ENUM_LABEL_INPUT_DESCRIPTOR_LABEL_SHOW,
MENU_ENUM_LABEL_VALUE_INPUT_DESCRIPTOR_LABEL_SHOW,
DEFAULT_INPUT_DESCRIPTOR_LABEL_SHOW,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED
);
CONFIG_BOOL(
list, list_info,
&settings->bools.input_descriptor_hide_unbound,
MENU_ENUM_LABEL_INPUT_DESCRIPTOR_HIDE_UNBOUND,
MENU_ENUM_LABEL_VALUE_INPUT_DESCRIPTOR_HIDE_UNBOUND,
DEFAULT_INPUT_DESCRIPTOR_HIDE_UNBOUND,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED
);
#endif
END_SUB_GROUP(list, list_info, parent_group);
START_SUB_GROUP(
list,
list_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_TURBO_DEADZONE_LIST),
&group_info,
&subgroup_info,
parent_group);
CONFIG_FLOAT(
list, list_info,
&settings->floats.input_axis_threshold,
MENU_ENUM_LABEL_INPUT_BUTTON_AXIS_THRESHOLD,
MENU_ENUM_LABEL_VALUE_INPUT_BUTTON_AXIS_THRESHOLD,
DEFAULT_AXIS_THRESHOLD,
"%.3f",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0.05, 0.99, 0.01, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_FLOAT(
list, list_info,
&settings->floats.input_analog_deadzone,
MENU_ENUM_LABEL_INPUT_ANALOG_DEADZONE,
MENU_ENUM_LABEL_VALUE_INPUT_ANALOG_DEADZONE,
DEFAULT_ANALOG_DEADZONE,
"%.1f",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0, 1.0, 0.1, true, true);
CONFIG_FLOAT(
list, list_info,
&settings->floats.input_analog_sensitivity,
MENU_ENUM_LABEL_INPUT_ANALOG_SENSITIVITY,
MENU_ENUM_LABEL_VALUE_INPUT_ANALOG_SENSITIVITY,
DEFAULT_ANALOG_SENSITIVITY,
"%.1f",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, -5.0, 5.0, 0.1, true, true);
CONFIG_UINT(
list, list_info,
&settings->uints.input_bind_timeout,
MENU_ENUM_LABEL_INPUT_BIND_TIMEOUT,
MENU_ENUM_LABEL_VALUE_INPUT_BIND_TIMEOUT,
DEFAULT_INPUT_BIND_TIMEOUT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].offset_by = 1;
menu_settings_list_current_add_range(list, list_info, 1, 5, 1, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
CONFIG_UINT(
list, list_info,
&settings->uints.input_bind_hold,
MENU_ENUM_LABEL_INPUT_BIND_HOLD,
MENU_ENUM_LABEL_VALUE_INPUT_BIND_HOLD,
DEFAULT_INPUT_BIND_HOLD,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].offset_by = 0;
menu_settings_list_current_add_range(list, list_info, 0, 5, 1, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_INPUT_HAPTIC_FEEDBACK_SETTINGS,
MENU_ENUM_LABEL_VALUE_INPUT_HAPTIC_FEEDBACK_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_INPUT_MENU_SETTINGS,
MENU_ENUM_LABEL_VALUE_INPUT_MENU_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
END_SUB_GROUP(list, list_info, parent_group);
START_SUB_GROUP(list, list_info, "Binds", &group_info, &subgroup_info, parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_INPUT_HOTKEY_BINDS,
MENU_ENUM_LABEL_VALUE_INPUT_HOTKEY_BINDS,
&group_info,
&subgroup_info,
parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_INPUT_RETROPAD_BINDS,
MENU_ENUM_LABEL_VALUE_INPUT_RETROPAD_BINDS,
&group_info,
&subgroup_info,
parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_INPUT_TURBO_FIRE_SETTINGS,
MENU_ENUM_LABEL_VALUE_INPUT_TURBO_FIRE_SETTINGS,
&group_info,
&subgroup_info,
parent_group);
{
const char *val_input_user_binds =
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_INPUT_USER_BINDS);
for (user = 0; user < MAX_USERS; user++)
{
static char binds_list[MAX_USERS][255];
static char binds_label[MAX_USERS][255];
unsigned user_value = user + 1;
size_t _len = snprintf(binds_list[user], sizeof(binds_list[user]), "%d", user_value);
strlcpy(binds_list[user] + _len, "_input_binds_list", sizeof(binds_list[user]) - _len);
snprintf(binds_label[user], sizeof(binds_label[user]),
val_input_user_binds, user_value);
CONFIG_ACTION_ALT(
list, list_info,
binds_list[user],
binds_label[user],
&group_info,
&subgroup_info,
parent_group);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_BIND_BUTTON;
(*list)[list_info->index - 1].index = user_value;
(*list)[list_info->index - 1].index_offset = user;
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_IDX_PTR(list, list_info, (enum msg_hash_enums)(MENU_ENUM_LABEL_INPUT_USER_1_BINDS + user));
}
}
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
}
break;
case SETTINGS_LIST_INPUT_TURBO_FIRE:
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_INPUT_TURBO_FIRE_SETTINGS),
parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_INPUT_TURBO_FIRE_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
CONFIG_UINT(
list, list_info,
&settings->uints.input_turbo_period,
MENU_ENUM_LABEL_INPUT_TURBO_PERIOD,
MENU_ENUM_LABEL_VALUE_INPUT_TURBO_PERIOD,
DEFAULT_TURBO_PERIOD,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].offset_by = 1;
menu_settings_list_current_add_range(list, list_info, 1, 100, 1, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
CONFIG_UINT(
list, list_info,
&settings->uints.input_turbo_duty_cycle,
MENU_ENUM_LABEL_INPUT_DUTY_CYCLE,
MENU_ENUM_LABEL_VALUE_INPUT_DUTY_CYCLE,
DEFAULT_TURBO_DUTY_CYCLE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].offset_by = 1;
menu_settings_list_current_add_range(list, list_info, 1, 100, 1, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
CONFIG_UINT(
list, list_info,
&settings->uints.input_turbo_mode,
MENU_ENUM_LABEL_INPUT_TURBO_MODE,
MENU_ENUM_LABEL_VALUE_INPUT_TURBO_MODE,
DEFAULT_TURBO_MODE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_turbo_mode;
menu_settings_list_current_add_range(list, list_info, 0, (INPUT_TURBO_MODE_LAST-1), 1, true, true);
CONFIG_UINT(
list, list_info,
&settings->uints.input_turbo_default_button,
MENU_ENUM_LABEL_INPUT_TURBO_DEFAULT_BUTTON,
MENU_ENUM_LABEL_VALUE_INPUT_TURBO_DEFAULT_BUTTON,
DEFAULT_TURBO_DEFAULT_BTN,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_turbo_default_button;
menu_settings_list_current_add_range(list, list_info, 0, (INPUT_TURBO_DEFAULT_BUTTON_LAST-1), 1, true, true);
CONFIG_BOOL(
list, list_info,
&settings->bools.input_allow_turbo_dpad,
MENU_ENUM_LABEL_INPUT_ALLOW_TURBO_DPAD,
MENU_ENUM_LABEL_VALUE_INPUT_ALLOW_TURBO_DPAD,
DEFAULT_ALLOW_TURBO_DPAD,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
case SETTINGS_LIST_RECORDING:
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_RECORDING_SETTINGS),
parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_RECORDING_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
CONFIG_UINT(
list, list_info,
&settings->uints.video_record_quality,
MENU_ENUM_LABEL_VIDEO_RECORD_QUALITY,
MENU_ENUM_LABEL_VALUE_VIDEO_RECORD_QUALITY,
RECORD_CONFIG_TYPE_RECORDING_MED_QUALITY,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_video_record_quality;
menu_settings_list_current_add_range(list, list_info, RECORD_CONFIG_TYPE_RECORDING_CUSTOM, RECORD_CONFIG_TYPE_RECORDING_APNG, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
CONFIG_PATH(
list, list_info,
settings->paths.path_record_config,
sizeof(settings->paths.path_record_config),
MENU_ENUM_LABEL_RECORD_CONFIG,
MENU_ENUM_LABEL_VALUE_RECORD_CONFIG,
"",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
MENU_SETTINGS_LIST_CURRENT_ADD_VALUES(list, list_info, "cfg");
CONFIG_STRING(
list, list_info,
settings->paths.streaming_title,
sizeof(settings->paths.streaming_title),
MENU_ENUM_LABEL_STREAMING_TITLE,
MENU_ENUM_LABEL_VALUE_STREAMING_TITLE,
"",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_STRING_LINE_EDIT;
(*list)[list_info->index - 1].action_start = setting_generic_action_start_default;
CONFIG_UINT(
list, list_info,
&settings->uints.streaming_mode,
MENU_ENUM_LABEL_STREAMING_MODE,
MENU_ENUM_LABEL_VALUE_STREAMING_MODE,
STREAMING_MODE_TWITCH,
&group_info,
&subgroup_info,
parent_group,
update_streaming_url_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_streaming_mode;
menu_settings_list_current_add_range(list, list_info, 0, STREAMING_MODE_CUSTOM, 1, true, true);
CONFIG_UINT(
list, list_info,
&settings->uints.video_stream_port,
MENU_ENUM_LABEL_UDP_STREAM_PORT,
MENU_ENUM_LABEL_VALUE_UDP_STREAM_PORT,
RARCH_STREAM_DEFAULT_PORT,
&group_info,
&subgroup_info,
parent_group,
update_streaming_url_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].offset_by = 1;
menu_settings_list_current_add_range(list, list_info, 1, 65536, 1, true, true);
CONFIG_UINT(
list, list_info,
&settings->uints.video_stream_quality,
MENU_ENUM_LABEL_VIDEO_STREAM_QUALITY,
MENU_ENUM_LABEL_VALUE_VIDEO_STREAM_QUALITY,
RECORD_CONFIG_TYPE_STREAMING_MED_QUALITY,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_video_stream_quality;
(*list)[list_info->index - 1].offset_by = RECORD_CONFIG_TYPE_STREAMING_CUSTOM;
menu_settings_list_current_add_range(list, list_info, RECORD_CONFIG_TYPE_STREAMING_CUSTOM, RECORD_CONFIG_TYPE_STREAMING_HIGH_QUALITY, 1, true, true);
CONFIG_PATH(
list, list_info,
settings->paths.path_stream_config,
sizeof(settings->paths.path_stream_config),
MENU_ENUM_LABEL_STREAM_CONFIG,
MENU_ENUM_LABEL_VALUE_STREAM_CONFIG,
"",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
MENU_SETTINGS_LIST_CURRENT_ADD_VALUES(list, list_info, "cfg");
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_FILE_SELECTOR;
CONFIG_STRING(
list, list_info,
settings->paths.path_stream_url,
sizeof(settings->paths.path_stream_url),
MENU_ENUM_LABEL_STREAMING_URL,
MENU_ENUM_LABEL_VALUE_STREAMING_URL,
"",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_STRING_LINE_EDIT;
(*list)[list_info->index - 1].action_start = setting_generic_action_start_default;
CONFIG_UINT(
list, list_info,
&settings->uints.video_record_threads,
MENU_ENUM_LABEL_VIDEO_RECORD_THREADS,
MENU_ENUM_LABEL_VALUE_VIDEO_RECORD_THREADS,
DEFAULT_VIDEO_RECORD_THREADS,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint_special;
menu_settings_list_current_add_range(list, list_info, 1, 8, 1, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
CONFIG_DIR(
list, list_info,
recording_st->output_dir,
sizeof(recording_st->output_dir),
MENU_ENUM_LABEL_RECORDING_OUTPUT_DIRECTORY,
MENU_ENUM_LABEL_VALUE_RECORDING_OUTPUT_DIRECTORY,
g_defaults.dirs[DEFAULT_DIR_RECORD_OUTPUT],
MENU_ENUM_LABEL_VALUE_DIRECTORY_DEFAULT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
END_SUB_GROUP(list, list_info, parent_group);
START_SUB_GROUP(list, list_info, "Miscellaneous", &group_info, &subgroup_info, parent_group);
CONFIG_BOOL(
list, list_info,
&settings->bools.video_post_filter_record,
MENU_ENUM_LABEL_VIDEO_POST_FILTER_RECORD,
MENU_ENUM_LABEL_VALUE_VIDEO_POST_FILTER_RECORD,
DEFAULT_POST_FILTER_RECORD,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.video_gpu_record,
MENU_ENUM_LABEL_VIDEO_GPU_RECORD,
MENU_ENUM_LABEL_VALUE_VIDEO_GPU_RECORD,
DEFAULT_GPU_RECORD,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
case SETTINGS_LIST_INPUT_HOTKEY:
{
unsigned i;
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_INPUT_HOTKEY_BINDS_BEGIN),
parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info,
parent_group);
for (i = 0; i < RARCH_BIND_LIST_END; i ++)
{
if (!input_config_bind_map_get_meta(i))
continue;
#ifndef HAVE_QT
if (i == RARCH_UI_COMPANION_TOGGLE)
continue;
#endif
CONFIG_BIND_ALT(
list, list_info,
&input_config_binds[0][i],
0, 0,
strdup(input_config_bind_map_get_base(i)),
strdup(input_config_bind_map_get_desc(i)),
&retro_keybinds_1[i],
&group_info, &subgroup_info, parent_group);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_BIND_BUTTON;
(*list)[list_info->index - 1].bind_type = i + MENU_SETTINGS_BIND_BEGIN;
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_IDX_PTR(list, list_info,
(enum msg_hash_enums)(MENU_ENUM_LABEL_INPUT_HOTKEY_BIND_BEGIN + i));
}
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
}
break;
case SETTINGS_LIST_FRAME_THROTTLING:
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_FRAME_THROTTLE_SETTINGS),
parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_FRAME_THROTTLE_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
CONFIG_FLOAT(
list, list_info,
&settings->floats.fastforward_ratio,
MENU_ENUM_LABEL_FASTFORWARD_RATIO,
MENU_ENUM_LABEL_VALUE_FASTFORWARD_RATIO,
DEFAULT_FASTFORWARD_RATIO,
"%.1fx",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_SET_FRAME_LIMIT);
menu_settings_list_current_add_range(list, list_info, 0, MAXIMUM_FASTFORWARD_RATIO, 1.0, true, true);
CONFIG_BOOL(
list, list_info,
&settings->bools.fastforward_frameskip,
MENU_ENUM_LABEL_FASTFORWARD_FRAMESKIP,
MENU_ENUM_LABEL_VALUE_FASTFORWARD_FRAMESKIP,
DEFAULT_FASTFORWARD_FRAMESKIP,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.vrr_runloop_enable,
MENU_ENUM_LABEL_VRR_RUNLOOP_ENABLE,
MENU_ENUM_LABEL_VALUE_VRR_RUNLOOP_ENABLE,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
(*list)[list_info->index - 1].action_ok = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_bool_action_right_with_refresh;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_REINIT);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_CMD_APPLY_AUTO);
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_throttle_framerate,
MENU_ENUM_LABEL_MENU_THROTTLE_FRAMERATE,
MENU_ENUM_LABEL_VALUE_MENU_ENUM_THROTTLE_FRAMERATE,
true,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED
);
CONFIG_FLOAT(
list, list_info,
&settings->floats.slowmotion_ratio,
MENU_ENUM_LABEL_SLOWMOTION_RATIO,
MENU_ENUM_LABEL_VALUE_SLOWMOTION_RATIO,
DEFAULT_SLOWMOTION_RATIO,
"%.1fx",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 1, 10, 0.1, true, true);
#ifdef HAVE_RUNAHEAD
CONFIG_BOOL(
list, list_info,
&settings->bools.run_ahead_enabled,
MENU_ENUM_LABEL_RUN_AHEAD_ENABLED,
MENU_ENUM_LABEL_VALUE_RUN_AHEAD_ENABLED,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
(*list)[list_info->index - 1].change_handler = runahead_change_handler;
CONFIG_UINT(
list, list_info,
&settings->uints.run_ahead_frames,
MENU_ENUM_LABEL_RUN_AHEAD_FRAMES,
MENU_ENUM_LABEL_VALUE_RUN_AHEAD_FRAMES,
1,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].offset_by = 1;
(*list)[list_info->index - 1].change_handler = runahead_change_handler;
menu_settings_list_current_add_range(list, list_info, 1, MAX_RUNAHEAD_FRAMES, 1, true, true);
#if defined(HAVE_DYNAMIC) || defined(HAVE_DYLIB)
CONFIG_BOOL(
list, list_info,
&settings->bools.run_ahead_secondary_instance,
MENU_ENUM_LABEL_RUN_AHEAD_SECONDARY_INSTANCE,
MENU_ENUM_LABEL_VALUE_RUN_AHEAD_SECONDARY_INSTANCE,
DEFAULT_RUN_AHEAD_SECONDARY_INSTANCE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
(*list)[list_info->index - 1].change_handler = runahead_change_handler;
#endif
CONFIG_BOOL(
list, list_info,
&settings->bools.run_ahead_hide_warnings,
MENU_ENUM_LABEL_RUN_AHEAD_HIDE_WARNINGS,
MENU_ENUM_LABEL_VALUE_RUN_AHEAD_HIDE_WARNINGS,
DEFAULT_RUN_AHEAD_HIDE_WARNINGS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED
);
CONFIG_BOOL(
list, list_info,
&settings->bools.preemptive_frames_enable,
MENU_ENUM_LABEL_PREEMPT_ENABLE,
MENU_ENUM_LABEL_VALUE_PREEMPT_ENABLE,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].change_handler = preempt_change_handler;
CONFIG_UINT(
list, list_info,
&settings->uints.run_ahead_frames,
MENU_ENUM_LABEL_PREEMPT_FRAMES,
MENU_ENUM_LABEL_VALUE_PREEMPT_FRAMES,
1,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].offset_by = 1;
(*list)[list_info->index - 1].change_handler = preempt_change_handler;
menu_settings_list_current_add_range(list, list_info, 1, MAX_RUNAHEAD_FRAMES, 1, true, true);
CONFIG_BOOL(
list, list_info,
&settings->bools.preemptive_frames_hide_warnings,
MENU_ENUM_LABEL_PREEMPT_HIDE_WARNINGS,
MENU_ENUM_LABEL_VALUE_PREEMPT_HIDE_WARNINGS,
DEFAULT_PREEMPT_HIDE_WARNINGS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED
);
#endif
#ifdef ANDROID
CONFIG_UINT(
list, list_info,
&settings->uints.input_block_timeout,
MENU_ENUM_LABEL_INPUT_BLOCK_TIMEOUT,
MENU_ENUM_LABEL_VALUE_INPUT_BLOCK_TIMEOUT,
0,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0, 4, 1, true, true);
#endif
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
case SETTINGS_LIST_ONSCREEN_NOTIFICATIONS:
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_ONSCREEN_DISPLAY_SETTINGS),
parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_ONSCREEN_DISPLAY_SETTINGS);
START_SUB_GROUP(list, list_info, "Notifications",
&group_info,
&subgroup_info,
parent_group);
#ifdef HAVE_GFX_WIDGETS
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_enable_widgets,
MENU_ENUM_LABEL_MENU_WIDGETS_ENABLE,
MENU_ENUM_LABEL_VALUE_MENU_WIDGETS_ENABLE,
DEFAULT_MENU_ENABLE_WIDGETS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].action_ok = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_bool_action_right_with_refresh;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_REINIT);
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_widget_scale_auto,
MENU_ENUM_LABEL_MENU_WIDGET_SCALE_AUTO,
MENU_ENUM_LABEL_VALUE_MENU_WIDGET_SCALE_AUTO,
DEFAULT_MENU_WIDGET_SCALE_AUTO,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
(*list)[list_info->index - 1].action_ok = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_bool_action_right_with_refresh;
#if (defined(RARCH_CONSOLE) || defined(RARCH_MOBILE))
CONFIG_FLOAT(
list, list_info,
&settings->floats.menu_widget_scale_factor,
MENU_ENUM_LABEL_MENU_WIDGET_SCALE_FACTOR,
MENU_ENUM_LABEL_VALUE_MENU_WIDGET_SCALE_FACTOR,
DEFAULT_MENU_WIDGET_SCALE_FACTOR,
"%.2fx",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
#else
CONFIG_FLOAT(
list, list_info,
&settings->floats.menu_widget_scale_factor,
MENU_ENUM_LABEL_MENU_WIDGET_SCALE_FACTOR,
MENU_ENUM_LABEL_VALUE_MENU_WIDGET_SCALE_FACTOR_FULLSCREEN,
DEFAULT_MENU_WIDGET_SCALE_FACTOR,
"%.2fx",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
#endif
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0.2, 5.0, 0.01, true, true);
#if !(defined(RARCH_CONSOLE) || defined(RARCH_MOBILE))
CONFIG_FLOAT(
list, list_info,
&settings->floats.menu_widget_scale_factor_windowed,
MENU_ENUM_LABEL_MENU_WIDGET_SCALE_FACTOR_WINDOWED,
MENU_ENUM_LABEL_VALUE_MENU_WIDGET_SCALE_FACTOR_WINDOWED,
DEFAULT_MENU_WIDGET_SCALE_FACTOR_WINDOWED,
"%.2fx",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0.2, 5.0, 0.01, true, true);
#endif
#endif
CONFIG_BOOL(
list, list_info,
&settings->bools.video_font_enable,
MENU_ENUM_LABEL_VIDEO_FONT_ENABLE,
MENU_ENUM_LABEL_VALUE_VIDEO_FONT_ENABLE,
DEFAULT_FONT_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
(*list)[list_info->index - 1].action_ok = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_bool_action_right_with_refresh;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_REINIT);
CONFIG_PATH(
list, list_info,
settings->paths.path_font,
sizeof(settings->paths.path_font),
MENU_ENUM_LABEL_VIDEO_FONT_PATH,
MENU_ENUM_LABEL_VALUE_VIDEO_FONT_PATH,
settings->paths.directory_assets,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].get_string_representation = &setting_get_string_representation_video_font_path;
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_FONT_SELECTOR;
MENU_SETTINGS_LIST_CURRENT_ADD_VALUES(list, list_info, "ttf");
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_REINIT);
CONFIG_FLOAT(
list, list_info,
&settings->floats.video_font_size,
MENU_ENUM_LABEL_VIDEO_FONT_SIZE,
MENU_ENUM_LABEL_VALUE_VIDEO_FONT_SIZE,
DEFAULT_FONT_SIZE,
"%.1f",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 1.00, 100.00, 1.0, true, true);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_REINIT);
CONFIG_FLOAT(
list, list_info,
&settings->floats.video_msg_pos_x,
MENU_ENUM_LABEL_VIDEO_MESSAGE_POS_X,
MENU_ENUM_LABEL_VALUE_VIDEO_MESSAGE_POS_X,
DEFAULT_MESSAGE_POS_OFFSET_X,
"%.3f",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0, 1, 0.01, true, true);
CONFIG_FLOAT(
list, list_info,
&settings->floats.video_msg_pos_y,
MENU_ENUM_LABEL_VIDEO_MESSAGE_POS_Y,
MENU_ENUM_LABEL_VALUE_VIDEO_MESSAGE_POS_Y,
DEFAULT_MESSAGE_POS_OFFSET_Y,
"%.3f",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0, 1, 0.01, true, true);
CONFIG_FLOAT(
list, list_info,
&settings->floats.video_msg_color_r,
MENU_ENUM_LABEL_VIDEO_MESSAGE_COLOR_RED,
MENU_ENUM_LABEL_VALUE_VIDEO_MESSAGE_COLOR_RED,
((DEFAULT_MESSAGE_COLOR >> 16) & 0xff) / 255.0f,
"%.3f",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
#if 0
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
#endif
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_float_video_msg_color;
menu_settings_list_current_add_range(list, list_info, 0, 1, 1.0f/255.0f, true, true);
CONFIG_FLOAT(
list, list_info,
&settings->floats.video_msg_color_g,
MENU_ENUM_LABEL_VIDEO_MESSAGE_COLOR_GREEN,
MENU_ENUM_LABEL_VALUE_VIDEO_MESSAGE_COLOR_GREEN,
((DEFAULT_MESSAGE_COLOR >> 8) & 0xff) / 255.0f,
"%.3f",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_float_video_msg_color;
menu_settings_list_current_add_range(list, list_info, 0, 1, 1.0f/255.0f, true, true);
CONFIG_FLOAT(
list, list_info,
&settings->floats.video_msg_color_b,
MENU_ENUM_LABEL_VIDEO_MESSAGE_COLOR_BLUE,
MENU_ENUM_LABEL_VALUE_VIDEO_MESSAGE_COLOR_BLUE,
((DEFAULT_MESSAGE_COLOR >> 0) & 0xff) / 255.0f,
"%.3f",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_float_video_msg_color;
menu_settings_list_current_add_range(list, list_info, 0, 1, 1.0f/255.0f, true, true);
CONFIG_BOOL(
list, list_info,
&settings->bools.video_msg_bgcolor_enable,
MENU_ENUM_LABEL_VIDEO_MESSAGE_BGCOLOR_ENABLE,
MENU_ENUM_LABEL_VALUE_VIDEO_MESSAGE_BGCOLOR_ENABLE,
DEFAULT_MESSAGE_BGCOLOR_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
(*list)[list_info->index - 1].action_ok = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_bool_action_right_with_refresh;
CONFIG_UINT(
list, list_info,
&settings->uints.video_msg_bgcolor_red,
MENU_ENUM_LABEL_VIDEO_MESSAGE_BGCOLOR_RED,
MENU_ENUM_LABEL_VALUE_VIDEO_MESSAGE_BGCOLOR_RED,
DEFAULT_MESSAGE_BGCOLOR_RED,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
menu_settings_list_current_add_range(list, list_info, 0, 255, 1, true, true);
CONFIG_UINT(
list, list_info,
&settings->uints.video_msg_bgcolor_green,
MENU_ENUM_LABEL_VIDEO_MESSAGE_BGCOLOR_GREEN,
MENU_ENUM_LABEL_VALUE_VIDEO_MESSAGE_BGCOLOR_GREEN,
DEFAULT_MESSAGE_BGCOLOR_GREEN,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
menu_settings_list_current_add_range(list, list_info, 0, 255, 1, true, true);
CONFIG_UINT(
list, list_info,
&settings->uints.video_msg_bgcolor_blue,
MENU_ENUM_LABEL_VIDEO_MESSAGE_BGCOLOR_BLUE,
MENU_ENUM_LABEL_VALUE_VIDEO_MESSAGE_BGCOLOR_BLUE,
DEFAULT_MESSAGE_BGCOLOR_BLUE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0, 255, 1, true, true);
CONFIG_FLOAT(
list, list_info,
&settings->floats.video_msg_bgcolor_opacity,
MENU_ENUM_LABEL_VIDEO_MESSAGE_BGCOLOR_OPACITY,
MENU_ENUM_LABEL_VALUE_VIDEO_MESSAGE_BGCOLOR_OPACITY,
DEFAULT_MESSAGE_BGCOLOR_OPACITY,
"%.2f",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0, 1, 0.01, true, true);
END_SUB_GROUP(list, list_info, parent_group);
START_SUB_GROUP(list, list_info, "Notification Views", &group_info, &subgroup_info, parent_group);
CONFIG_BOOL(
list, list_info,
&settings->bools.video_fps_show,
MENU_ENUM_LABEL_FPS_SHOW,
MENU_ENUM_LABEL_VALUE_FPS_SHOW,
DEFAULT_FPS_SHOW,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].action_ok = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_bool_action_right_with_refresh;
CONFIG_UINT(
list, list_info,
&settings->uints.fps_update_interval,
MENU_ENUM_LABEL_FPS_UPDATE_INTERVAL,
MENU_ENUM_LABEL_VALUE_FPS_UPDATE_INTERVAL,
DEFAULT_FPS_UPDATE_INTERVAL,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint_special;
menu_settings_list_current_add_range(list, list_info, 1, 512, 1, true, true);
CONFIG_BOOL(
list, list_info,
&settings->bools.video_memory_show,
MENU_ENUM_LABEL_MEMORY_SHOW,
MENU_ENUM_LABEL_VALUE_MEMORY_SHOW,
DEFAULT_MEMORY_SHOW,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].action_ok = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_bool_action_right_with_refresh;
CONFIG_UINT(
list, list_info,
&settings->uints.memory_update_interval,
MENU_ENUM_LABEL_MEMORY_UPDATE_INTERVAL,
MENU_ENUM_LABEL_VALUE_MEMORY_UPDATE_INTERVAL,
DEFAULT_MEMORY_UPDATE_INTERVAL,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint_special;
menu_settings_list_current_add_range(list, list_info, 1, 512, 1, true, true);
CONFIG_BOOL(
list, list_info,
&settings->bools.video_statistics_show,
MENU_ENUM_LABEL_STATISTICS_SHOW,
MENU_ENUM_LABEL_VALUE_STATISTICS_SHOW,
DEFAULT_STATISTICS_SHOW,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.video_framecount_show,
MENU_ENUM_LABEL_FRAMECOUNT_SHOW,
MENU_ENUM_LABEL_VALUE_FRAMECOUNT_SHOW,
DEFAULT_FRAMECOUNT_SHOW,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#ifdef HAVE_GFX_WIDGETS
#ifdef HAVE_NETWORKING
CONFIG_BOOL(
list, list_info,
&settings->bools.netplay_ping_show,
MENU_ENUM_LABEL_NETPLAY_PING_SHOW,
MENU_ENUM_LABEL_VALUE_NETPLAY_PING_SHOW,
DEFAULT_NETPLAY_PING_SHOW,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].action_ok = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_bool_action_right_with_refresh;
#endif
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_show_load_content_animation,
MENU_ENUM_LABEL_MENU_SHOW_LOAD_CONTENT_ANIMATION,
MENU_ENUM_LABEL_VALUE_MENU_SHOW_LOAD_CONTENT_ANIMATION,
DEFAULT_MENU_SHOW_LOAD_CONTENT_ANIMATION,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#endif
CONFIG_BOOL(
list, list_info,
&settings->bools.notification_show_autoconfig,
MENU_ENUM_LABEL_NOTIFICATION_SHOW_AUTOCONFIG,
MENU_ENUM_LABEL_VALUE_NOTIFICATION_SHOW_AUTOCONFIG,
DEFAULT_NOTIFICATION_SHOW_AUTOCONFIG,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#ifdef HAVE_CHEATS
CONFIG_BOOL(
list, list_info,
&settings->bools.notification_show_cheats_applied,
MENU_ENUM_LABEL_NOTIFICATION_SHOW_CHEATS_APPLIED,
MENU_ENUM_LABEL_VALUE_NOTIFICATION_SHOW_CHEATS_APPLIED,
DEFAULT_NOTIFICATION_SHOW_CHEATS_APPLIED,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#endif
#ifdef HAVE_PATCH
CONFIG_BOOL(
list, list_info,
&settings->bools.notification_show_patch_applied,
MENU_ENUM_LABEL_NOTIFICATION_SHOW_PATCH_APPLIED,
MENU_ENUM_LABEL_VALUE_NOTIFICATION_SHOW_PATCH_APPLIED,
DEFAULT_NOTIFICATION_SHOW_PATCH_APPLIED,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#endif
CONFIG_BOOL(
list, list_info,
&settings->bools.notification_show_remap_load,
MENU_ENUM_LABEL_NOTIFICATION_SHOW_REMAP_LOAD,
MENU_ENUM_LABEL_VALUE_NOTIFICATION_SHOW_REMAP_LOAD,
DEFAULT_NOTIFICATION_SHOW_REMAP_LOAD,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.notification_show_config_override_load,
MENU_ENUM_LABEL_NOTIFICATION_SHOW_CONFIG_OVERRIDE_LOAD,
MENU_ENUM_LABEL_VALUE_NOTIFICATION_SHOW_CONFIG_OVERRIDE_LOAD,
DEFAULT_NOTIFICATION_SHOW_CONFIG_OVERRIDE_LOAD,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.notification_show_set_initial_disk,
MENU_ENUM_LABEL_NOTIFICATION_SHOW_SET_INITIAL_DISK,
MENU_ENUM_LABEL_VALUE_NOTIFICATION_SHOW_SET_INITIAL_DISK,
DEFAULT_NOTIFICATION_SHOW_SET_INITIAL_DISK,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.notification_show_disk_control,
MENU_ENUM_LABEL_NOTIFICATION_SHOW_DISK_CONTROL,
MENU_ENUM_LABEL_VALUE_NOTIFICATION_SHOW_DISK_CONTROL,
DEFAULT_NOTIFICATION_SHOW_DISK_CONTROL,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.notification_show_save_state,
MENU_ENUM_LABEL_NOTIFICATION_SHOW_SAVE_STATE,
MENU_ENUM_LABEL_VALUE_NOTIFICATION_SHOW_SAVE_STATE,
DEFAULT_NOTIFICATION_SHOW_SAVE_STATE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.notification_show_fast_forward,
MENU_ENUM_LABEL_NOTIFICATION_SHOW_FAST_FORWARD,
MENU_ENUM_LABEL_VALUE_NOTIFICATION_SHOW_FAST_FORWARD,
DEFAULT_NOTIFICATION_SHOW_FAST_FORWARD,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#ifdef HAVE_SCREENSHOTS
CONFIG_BOOL(
list, list_info,
&settings->bools.notification_show_screenshot,
MENU_ENUM_LABEL_NOTIFICATION_SHOW_SCREENSHOT,
MENU_ENUM_LABEL_VALUE_NOTIFICATION_SHOW_SCREENSHOT,
DEFAULT_NOTIFICATION_SHOW_SCREENSHOT,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].action_ok = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_bool_action_right_with_refresh;
#ifdef HAVE_GFX_WIDGETS
CONFIG_UINT(
list, list_info,
&settings->uints.notification_show_screenshot_duration,
MENU_ENUM_LABEL_NOTIFICATION_SHOW_SCREENSHOT_DURATION,
MENU_ENUM_LABEL_VALUE_NOTIFICATION_SHOW_SCREENSHOT_DURATION,
DEFAULT_NOTIFICATION_SHOW_SCREENSHOT_DURATION,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_notification_show_screenshot_duration;
menu_settings_list_current_add_range(list, list_info, 0, NOTIFICATION_SHOW_SCREENSHOT_DURATION_LAST-1, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
CONFIG_UINT(
list, list_info,
&settings->uints.notification_show_screenshot_flash,
MENU_ENUM_LABEL_NOTIFICATION_SHOW_SCREENSHOT_FLASH,
MENU_ENUM_LABEL_VALUE_NOTIFICATION_SHOW_SCREENSHOT_FLASH,
DEFAULT_NOTIFICATION_SHOW_SCREENSHOT_FLASH,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_notification_show_screenshot_flash;
menu_settings_list_current_add_range(list, list_info, 0, NOTIFICATION_SHOW_SCREENSHOT_FLASH_LAST-1, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
#endif
#endif
CONFIG_BOOL(
list, list_info,
&settings->bools.notification_show_refresh_rate,
MENU_ENUM_LABEL_NOTIFICATION_SHOW_REFRESH_RATE,
MENU_ENUM_LABEL_VALUE_NOTIFICATION_SHOW_REFRESH_RATE,
DEFAULT_NOTIFICATION_SHOW_REFRESH_RATE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#ifdef HAVE_NETWORKING
CONFIG_BOOL(
list, list_info,
&settings->bools.notification_show_netplay_extra,
MENU_ENUM_LABEL_NOTIFICATION_SHOW_NETPLAY_EXTRA,
MENU_ENUM_LABEL_VALUE_NOTIFICATION_SHOW_NETPLAY_EXTRA,
DEFAULT_NOTIFICATION_SHOW_NETPLAY_EXTRA,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#endif
CONFIG_BOOL(
list, list_info,
&settings->bools.notification_show_when_menu_is_alive,
MENU_ENUM_LABEL_NOTIFICATION_SHOW_WHEN_MENU_IS_ALIVE,
MENU_ENUM_LABEL_VALUE_NOTIFICATION_SHOW_WHEN_MENU_IS_ALIVE,
DEFAULT_NOTIFICATION_SHOW_WHEN_MENU_IS_ALIVE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
case SETTINGS_LIST_OVERLAY:
#ifdef HAVE_OVERLAY
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OVERLAY_SETTINGS),
parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_OVERLAY_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
CONFIG_BOOL(
list, list_info,
&settings->bools.input_overlay_enable,
MENU_ENUM_LABEL_INPUT_OVERLAY_ENABLE,
MENU_ENUM_LABEL_VALUE_INPUT_OVERLAY_ENABLE,
config_overlay_enable_default(),
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
(*list)[list_info->index - 1].action_ok = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_bool_action_right_with_refresh;
(*list)[list_info->index - 1].change_handler = overlay_enable_toggle_change_handler;
CONFIG_BOOL(
list, list_info,
&settings->bools.input_overlay_enable_autopreferred,
MENU_ENUM_LABEL_OVERLAY_AUTOLOAD_PREFERRED,
MENU_ENUM_LABEL_VALUE_OVERLAY_AUTOLOAD_PREFERRED,
DEFAULT_OVERLAY_ENABLE_AUTOPREFERRED,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
(*list)[list_info->index - 1].change_handler = overlay_enable_toggle_change_handler;
if (video_driver_test_all_flags(GFX_CTX_FLAGS_OVERLAY_BEHIND_MENU_SUPPORTED))
{
CONFIG_BOOL(
list, list_info,
&settings->bools.input_overlay_behind_menu,
MENU_ENUM_LABEL_INPUT_OVERLAY_BEHIND_MENU,
MENU_ENUM_LABEL_VALUE_INPUT_OVERLAY_BEHIND_MENU,
DEFAULT_OVERLAY_BEHIND_MENU,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
}
CONFIG_BOOL(
list, list_info,
&settings->bools.input_overlay_hide_in_menu,
MENU_ENUM_LABEL_INPUT_OVERLAY_HIDE_IN_MENU,
MENU_ENUM_LABEL_VALUE_INPUT_OVERLAY_HIDE_IN_MENU,
DEFAULT_OVERLAY_HIDE_IN_MENU,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
(*list)[list_info->index - 1].change_handler = overlay_enable_toggle_change_handler;
CONFIG_BOOL(
list, list_info,
&settings->bools.input_overlay_hide_when_gamepad_connected,
MENU_ENUM_LABEL_INPUT_OVERLAY_HIDE_WHEN_GAMEPAD_CONNECTED,
MENU_ENUM_LABEL_VALUE_INPUT_OVERLAY_HIDE_WHEN_GAMEPAD_CONNECTED,
DEFAULT_OVERLAY_HIDE_WHEN_GAMEPAD_CONNECTED,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
(*list)[list_info->index - 1].change_handler = overlay_enable_toggle_change_handler;
CONFIG_UINT(
list, list_info,
&settings->uints.input_overlay_show_inputs,
MENU_ENUM_LABEL_INPUT_OVERLAY_SHOW_INPUTS,
MENU_ENUM_LABEL_VALUE_INPUT_OVERLAY_SHOW_INPUTS,
DEFAULT_OVERLAY_SHOW_INPUTS,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler
);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].action_left = &setting_uint_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_uint_action_right_with_refresh;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_input_overlay_show_inputs;
menu_settings_list_current_add_range(list, list_info, 0, OVERLAY_SHOW_INPUT_LAST-1, 1, true, true);
CONFIG_UINT(
list, list_info,
&settings->uints.input_overlay_show_inputs_port,
MENU_ENUM_LABEL_INPUT_OVERLAY_SHOW_INPUTS_PORT,
MENU_ENUM_LABEL_VALUE_INPUT_OVERLAY_SHOW_INPUTS_PORT,
DEFAULT_OVERLAY_SHOW_INPUTS_PORT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler
);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_input_overlay_show_inputs_port;
menu_settings_list_current_add_range(list, list_info, 0, MAX_USERS - 1, 1, true, true);
CONFIG_BOOL(
list, list_info,
&settings->bools.input_overlay_show_mouse_cursor,
MENU_ENUM_LABEL_INPUT_OVERLAY_SHOW_MOUSE_CURSOR,
MENU_ENUM_LABEL_VALUE_INPUT_OVERLAY_SHOW_MOUSE_CURSOR,
DEFAULT_OVERLAY_SHOW_MOUSE_CURSOR,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
(*list)[list_info->index - 1].change_handler = overlay_show_mouse_cursor_change_handler;
CONFIG_BOOL(
list, list_info,
&settings->bools.input_overlay_auto_rotate,
MENU_ENUM_LABEL_INPUT_OVERLAY_AUTO_ROTATE,
MENU_ENUM_LABEL_VALUE_INPUT_OVERLAY_AUTO_ROTATE,
DEFAULT_OVERLAY_AUTO_ROTATE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
(*list)[list_info->index - 1].change_handler = overlay_enable_toggle_change_handler;
CONFIG_BOOL(
list, list_info,
&settings->bools.input_overlay_auto_scale,
MENU_ENUM_LABEL_INPUT_OVERLAY_AUTO_SCALE,
MENU_ENUM_LABEL_VALUE_INPUT_OVERLAY_AUTO_SCALE,
DEFAULT_INPUT_OVERLAY_AUTO_SCALE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
(*list)[list_info->index - 1].action_ok = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_bool_action_right_with_refresh;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_OVERLAY_SET_SCALE_FACTOR);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_CMD_APPLY_AUTO);
CONFIG_PATH(
list, list_info,
settings->paths.path_overlay,
sizeof(settings->paths.path_overlay),
MENU_ENUM_LABEL_OVERLAY_PRESET,
MENU_ENUM_LABEL_VALUE_OVERLAY_PRESET,
settings->paths.directory_overlay,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
MENU_SETTINGS_LIST_CURRENT_ADD_VALUES(list, list_info, "cfg");
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_OVERLAY_INIT);
CONFIG_FLOAT(
list, list_info,
&settings->floats.input_overlay_opacity,
MENU_ENUM_LABEL_OVERLAY_OPACITY,
MENU_ENUM_LABEL_VALUE_OVERLAY_OPACITY,
DEFAULT_INPUT_OVERLAY_OPACITY,
"%.2f",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_OVERLAY_SET_ALPHA_MOD);
menu_settings_list_current_add_range(list, list_info, 0, 1, 0.01, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_CMD_APPLY_AUTO);
CONFIG_UINT(
list, list_info,
&settings->uints.input_overlay_dpad_diagonal_sensitivity,
MENU_ENUM_LABEL_INPUT_OVERLAY_DPAD_DIAGONAL_SENSITIVITY,
MENU_ENUM_LABEL_VALUE_INPUT_OVERLAY_DPAD_DIAGONAL_SENSITIVITY,
DEFAULT_OVERLAY_DPAD_DIAGONAL_SENSITIVITY,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler
);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_percentage;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_OVERLAY_SET_EIGHTWAY_DIAGONAL_SENSITIVITY);
menu_settings_list_current_add_range(list, list_info, 0, 100, 1, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_CMD_APPLY_AUTO);
CONFIG_UINT(
list, list_info,
&settings->uints.input_overlay_abxy_diagonal_sensitivity,
MENU_ENUM_LABEL_INPUT_OVERLAY_ABXY_DIAGONAL_SENSITIVITY,
MENU_ENUM_LABEL_VALUE_INPUT_OVERLAY_ABXY_DIAGONAL_SENSITIVITY,
DEFAULT_OVERLAY_ABXY_DIAGONAL_SENSITIVITY,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler
);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_percentage;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_OVERLAY_SET_EIGHTWAY_DIAGONAL_SENSITIVITY);
menu_settings_list_current_add_range(list, list_info, 0, 100, 1, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_CMD_APPLY_AUTO);
CONFIG_FLOAT(
list, list_info,
&settings->floats.input_overlay_scale_landscape,
MENU_ENUM_LABEL_OVERLAY_SCALE_LANDSCAPE,
MENU_ENUM_LABEL_VALUE_OVERLAY_SCALE_LANDSCAPE,
DEFAULT_INPUT_OVERLAY_SCALE_LANDSCAPE,
"%.3f",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_OVERLAY_SET_SCALE_FACTOR);
menu_settings_list_current_add_range(list, list_info, 0.0f, 2.0f, 0.005, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_CMD_APPLY_AUTO);
CONFIG_FLOAT(
list, list_info,
&settings->floats.input_overlay_aspect_adjust_landscape,
MENU_ENUM_LABEL_OVERLAY_ASPECT_ADJUST_LANDSCAPE,
MENU_ENUM_LABEL_VALUE_OVERLAY_ASPECT_ADJUST_LANDSCAPE,
DEFAULT_INPUT_OVERLAY_ASPECT_ADJUST_LANDSCAPE,
"%.3f",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_OVERLAY_SET_SCALE_FACTOR);
menu_settings_list_current_add_range(list, list_info, -2.0f, 2.0f, 0.005f, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_CMD_APPLY_AUTO);
CONFIG_FLOAT(
list, list_info,
&settings->floats.input_overlay_x_separation_landscape,
MENU_ENUM_LABEL_OVERLAY_X_SEPARATION_LANDSCAPE,
MENU_ENUM_LABEL_VALUE_OVERLAY_X_SEPARATION_LANDSCAPE,
DEFAULT_INPUT_OVERLAY_X_SEPARATION_LANDSCAPE,
"%.3f",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_OVERLAY_SET_SCALE_FACTOR);
menu_settings_list_current_add_range(list, list_info, -2.0f, 2.0f, 0.005f, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_CMD_APPLY_AUTO);
CONFIG_FLOAT(
list, list_info,
&settings->floats.input_overlay_y_separation_landscape,
MENU_ENUM_LABEL_OVERLAY_Y_SEPARATION_LANDSCAPE,
MENU_ENUM_LABEL_VALUE_OVERLAY_Y_SEPARATION_LANDSCAPE,
DEFAULT_INPUT_OVERLAY_Y_SEPARATION_LANDSCAPE,
"%.3f",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_OVERLAY_SET_SCALE_FACTOR);
menu_settings_list_current_add_range(list, list_info, -2.0f, 2.0f, 0.005f, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_CMD_APPLY_AUTO);
CONFIG_FLOAT(
list, list_info,
&settings->floats.input_overlay_x_offset_landscape,
MENU_ENUM_LABEL_OVERLAY_X_OFFSET_LANDSCAPE,
MENU_ENUM_LABEL_VALUE_OVERLAY_X_OFFSET_LANDSCAPE,
DEFAULT_INPUT_OVERLAY_X_OFFSET_LANDSCAPE,
"%.3f",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_OVERLAY_SET_SCALE_FACTOR);
menu_settings_list_current_add_range(list, list_info, -1.0f, 1.0f, 0.005f, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_CMD_APPLY_AUTO);
CONFIG_FLOAT(
list, list_info,
&settings->floats.input_overlay_y_offset_landscape,
MENU_ENUM_LABEL_OVERLAY_Y_OFFSET_LANDSCAPE,
MENU_ENUM_LABEL_VALUE_OVERLAY_Y_OFFSET_LANDSCAPE,
DEFAULT_INPUT_OVERLAY_Y_OFFSET_LANDSCAPE,
"%.3f",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_OVERLAY_SET_SCALE_FACTOR);
menu_settings_list_current_add_range(list, list_info, -1.0f, 1.0f, 0.005f, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_CMD_APPLY_AUTO);
CONFIG_FLOAT(
list, list_info,
&settings->floats.input_overlay_scale_portrait,
MENU_ENUM_LABEL_OVERLAY_SCALE_PORTRAIT,
MENU_ENUM_LABEL_VALUE_OVERLAY_SCALE_PORTRAIT,
DEFAULT_INPUT_OVERLAY_SCALE_PORTRAIT,
"%.3f",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_OVERLAY_SET_SCALE_FACTOR);
menu_settings_list_current_add_range(list, list_info, 0.0f, 2.0f, 0.005, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_CMD_APPLY_AUTO);
CONFIG_FLOAT(
list, list_info,
&settings->floats.input_overlay_aspect_adjust_portrait,
MENU_ENUM_LABEL_OVERLAY_ASPECT_ADJUST_PORTRAIT,
MENU_ENUM_LABEL_VALUE_OVERLAY_ASPECT_ADJUST_PORTRAIT,
DEFAULT_INPUT_OVERLAY_ASPECT_ADJUST_PORTRAIT,
"%.3f",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_OVERLAY_SET_SCALE_FACTOR);
menu_settings_list_current_add_range(list, list_info, -2.0f, 2.0f, 0.005f, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_CMD_APPLY_AUTO);
CONFIG_FLOAT(
list, list_info,
&settings->floats.input_overlay_x_separation_portrait,
MENU_ENUM_LABEL_OVERLAY_X_SEPARATION_PORTRAIT,
MENU_ENUM_LABEL_VALUE_OVERLAY_X_SEPARATION_PORTRAIT,
DEFAULT_INPUT_OVERLAY_X_SEPARATION_PORTRAIT,
"%.3f",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_OVERLAY_SET_SCALE_FACTOR);
menu_settings_list_current_add_range(list, list_info, -2.0f, 2.0f, 0.005f, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_CMD_APPLY_AUTO);
CONFIG_FLOAT(
list, list_info,
&settings->floats.input_overlay_y_separation_portrait,
MENU_ENUM_LABEL_OVERLAY_Y_SEPARATION_PORTRAIT,
MENU_ENUM_LABEL_VALUE_OVERLAY_Y_SEPARATION_PORTRAIT,
DEFAULT_INPUT_OVERLAY_Y_SEPARATION_PORTRAIT,
"%.3f",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_OVERLAY_SET_SCALE_FACTOR);
menu_settings_list_current_add_range(list, list_info, -2.0f, 2.0f, 0.005f, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_CMD_APPLY_AUTO);
CONFIG_FLOAT(
list, list_info,
&settings->floats.input_overlay_x_offset_portrait,
MENU_ENUM_LABEL_OVERLAY_X_OFFSET_PORTRAIT,
MENU_ENUM_LABEL_VALUE_OVERLAY_X_OFFSET_PORTRAIT,
DEFAULT_INPUT_OVERLAY_X_OFFSET_PORTRAIT,
"%.3f",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_OVERLAY_SET_SCALE_FACTOR);
menu_settings_list_current_add_range(list, list_info, -1.0f, 1.0f, 0.005f, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_CMD_APPLY_AUTO);
CONFIG_FLOAT(
list, list_info,
&settings->floats.input_overlay_y_offset_portrait,
MENU_ENUM_LABEL_OVERLAY_Y_OFFSET_PORTRAIT,
MENU_ENUM_LABEL_VALUE_OVERLAY_Y_OFFSET_PORTRAIT,
DEFAULT_INPUT_OVERLAY_Y_OFFSET_PORTRAIT,
"%.3f",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_OVERLAY_SET_SCALE_FACTOR);
menu_settings_list_current_add_range(list, list_info, -1.0f, 1.0f, 0.005f, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_CMD_APPLY_AUTO);
CONFIG_BOOL(
list, list_info,
&settings->bools.input_overlay_pointer_enable,
MENU_ENUM_LABEL_INPUT_OVERLAY_POINTER_ENABLE,
MENU_ENUM_LABEL_VALUE_INPUT_OVERLAY_POINTER_ENABLE,
DEFAULT_INPUT_OVERLAY_POINTER_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
(*list)[list_info->index - 1].action_ok = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_bool_action_right_with_refresh;
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
#endif
break;
case SETTINGS_LIST_OSK_OVERLAY:
#ifdef HAVE_OVERLAY
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OSK_OVERLAY_SETTINGS),
parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_OVERLAY_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
CONFIG_PATH(
list, list_info,
settings->paths.path_osk_overlay,
sizeof(settings->paths.path_osk_overlay),
MENU_ENUM_LABEL_OSK_OVERLAY_PRESET,
MENU_ENUM_LABEL_VALUE_OSK_OVERLAY_PRESET,
settings->paths.directory_osk_overlay,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
MENU_SETTINGS_LIST_CURRENT_ADD_VALUES(list, list_info, "cfg");
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_OVERLAY_INIT);
CONFIG_BOOL(
list, list_info,
&settings->bools.input_osk_overlay_auto_scale,
MENU_ENUM_LABEL_INPUT_OSK_OVERLAY_AUTO_SCALE,
MENU_ENUM_LABEL_VALUE_INPUT_OSK_OVERLAY_AUTO_SCALE,
DEFAULT_INPUT_OVERLAY_AUTO_SCALE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
(*list)[list_info->index - 1].action_ok = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_bool_action_right_with_refresh;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_OVERLAY_SET_SCALE_FACTOR);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_CMD_APPLY_AUTO);
CONFIG_FLOAT(
list, list_info,
&settings->floats.input_osk_overlay_opacity,
MENU_ENUM_LABEL_OSK_OVERLAY_OPACITY,
MENU_ENUM_LABEL_VALUE_OSK_OVERLAY_OPACITY,
DEFAULT_INPUT_OVERLAY_OPACITY,
"%.2f",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_OVERLAY_SET_ALPHA_MOD);
menu_settings_list_current_add_range(list, list_info, 0, 1, 0.01, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_CMD_APPLY_AUTO);
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
#endif
break;
case SETTINGS_LIST_OVERLAY_LIGHTGUN:
#ifdef HAVE_OVERLAY
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OVERLAY_LIGHTGUN_SETTINGS),
parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_OVERLAY_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
CONFIG_INT(
list, list_info,
&settings->ints.input_overlay_lightgun_port,
MENU_ENUM_LABEL_INPUT_OVERLAY_LIGHTGUN_PORT,
MENU_ENUM_LABEL_VALUE_INPUT_OVERLAY_LIGHTGUN_PORT,
DEFAULT_INPUT_OVERLAY_LIGHTGUN_PORT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].offset_by = -1;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_overlay_lightgun_port;
menu_settings_list_current_add_range(list, list_info, -1, MAX_USERS - 1, 1, true, true);
CONFIG_BOOL(
list, list_info,
&settings->bools.input_overlay_lightgun_trigger_on_touch,
MENU_ENUM_LABEL_INPUT_OVERLAY_LIGHTGUN_TRIGGER_ON_TOUCH,
MENU_ENUM_LABEL_VALUE_INPUT_OVERLAY_LIGHTGUN_TRIGGER_ON_TOUCH,
DEFAULT_INPUT_OVERLAY_LIGHTGUN_TRIGGER_ON_TOUCH,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_UINT(
list, list_info,
&settings->uints.input_overlay_lightgun_trigger_delay,
MENU_ENUM_LABEL_INPUT_OVERLAY_LIGHTGUN_TRIGGER_DELAY,
MENU_ENUM_LABEL_VALUE_INPUT_OVERLAY_LIGHTGUN_TRIGGER_DELAY,
DEFAULT_INPUT_OVERLAY_LIGHTGUN_TRIGGER_DELAY,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0,
OVERLAY_LIGHTGUN_TRIG_MAX_DELAY, 1, true, true);
CONFIG_UINT(
list, list_info,
&settings->uints.input_overlay_lightgun_two_touch_input,
MENU_ENUM_LABEL_INPUT_OVERLAY_LIGHTGUN_TWO_TOUCH_INPUT,
MENU_ENUM_LABEL_VALUE_INPUT_OVERLAY_LIGHTGUN_TWO_TOUCH_INPUT,
DEFAULT_INPUT_OVERLAY_LIGHTGUN_MULTI_TOUCH_INPUT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_overlay_lightgun_action;
menu_settings_list_current_add_range(list, list_info,
OVERLAY_LIGHTGUN_ACTION_NONE, OVERLAY_LIGHTGUN_ACTION_END - 1, 1, true, true);
CONFIG_UINT(
list, list_info,
&settings->uints.input_overlay_lightgun_three_touch_input,
MENU_ENUM_LABEL_INPUT_OVERLAY_LIGHTGUN_THREE_TOUCH_INPUT,
MENU_ENUM_LABEL_VALUE_INPUT_OVERLAY_LIGHTGUN_THREE_TOUCH_INPUT,
DEFAULT_INPUT_OVERLAY_LIGHTGUN_MULTI_TOUCH_INPUT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_overlay_lightgun_action;
menu_settings_list_current_add_range(list, list_info,
OVERLAY_LIGHTGUN_ACTION_NONE, OVERLAY_LIGHTGUN_ACTION_END - 1, 1, true, true);
CONFIG_UINT(
list, list_info,
&settings->uints.input_overlay_lightgun_four_touch_input,
MENU_ENUM_LABEL_INPUT_OVERLAY_LIGHTGUN_FOUR_TOUCH_INPUT,
MENU_ENUM_LABEL_VALUE_INPUT_OVERLAY_LIGHTGUN_FOUR_TOUCH_INPUT,
DEFAULT_INPUT_OVERLAY_LIGHTGUN_MULTI_TOUCH_INPUT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_overlay_lightgun_action;
menu_settings_list_current_add_range(list, list_info,
OVERLAY_LIGHTGUN_ACTION_NONE, OVERLAY_LIGHTGUN_ACTION_END - 1, 1, true, true);
CONFIG_BOOL(
list, list_info,
&settings->bools.input_overlay_lightgun_allow_offscreen,
MENU_ENUM_LABEL_INPUT_OVERLAY_LIGHTGUN_ALLOW_OFFSCREEN,
MENU_ENUM_LABEL_VALUE_INPUT_OVERLAY_LIGHTGUN_ALLOW_OFFSCREEN,
DEFAULT_INPUT_OVERLAY_LIGHTGUN_ALLOW_OFFSCREEN,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
#endif
break;
case SETTINGS_LIST_OVERLAY_MOUSE:
#ifdef HAVE_OVERLAY
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OVERLAY_MOUSE_SETTINGS),
parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_OVERLAY_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
CONFIG_FLOAT(
list, list_info,
&settings->floats.input_overlay_mouse_speed,
MENU_ENUM_LABEL_INPUT_OVERLAY_MOUSE_SPEED,
MENU_ENUM_LABEL_VALUE_INPUT_OVERLAY_MOUSE_SPEED,
DEFAULT_INPUT_OVERLAY_MOUSE_SPEED,
"%.1fx",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0.1, 5.0, 0.1, true, true);
CONFIG_BOOL(
list, list_info,
&settings->bools.input_overlay_mouse_hold_to_drag,
MENU_ENUM_LABEL_INPUT_OVERLAY_MOUSE_HOLD_TO_DRAG,
MENU_ENUM_LABEL_VALUE_INPUT_OVERLAY_MOUSE_HOLD_TO_DRAG,
DEFAULT_INPUT_OVERLAY_MOUSE_HOLD_TO_DRAG,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_UINT(
list, list_info,
&settings->uints.input_overlay_mouse_hold_msec,
MENU_ENUM_LABEL_INPUT_OVERLAY_MOUSE_HOLD_MSEC,
MENU_ENUM_LABEL_VALUE_INPUT_OVERLAY_MOUSE_HOLD_MSEC,
DEFAULT_INPUT_OVERLAY_MOUSE_HOLD_MSEC,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0, 1000, 1, true, true);
CONFIG_BOOL(
list, list_info,
&settings->bools.input_overlay_mouse_dtap_to_drag,
MENU_ENUM_LABEL_INPUT_OVERLAY_MOUSE_DTAP_TO_DRAG,
MENU_ENUM_LABEL_VALUE_INPUT_OVERLAY_MOUSE_DTAP_TO_DRAG,
DEFAULT_INPUT_OVERLAY_MOUSE_DTAP_TO_DRAG,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_UINT(
list, list_info,
&settings->uints.input_overlay_mouse_dtap_msec,
MENU_ENUM_LABEL_INPUT_OVERLAY_MOUSE_DTAP_MSEC,
MENU_ENUM_LABEL_VALUE_INPUT_OVERLAY_MOUSE_DTAP_MSEC,
DEFAULT_INPUT_OVERLAY_MOUSE_DTAP_MSEC,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0, 500, 1, true, true);
CONFIG_FLOAT(
list, list_info,
&settings->floats.input_overlay_mouse_swipe_threshold,
MENU_ENUM_LABEL_INPUT_OVERLAY_MOUSE_SWIPE_THRESHOLD,
MENU_ENUM_LABEL_VALUE_INPUT_OVERLAY_MOUSE_SWIPE_THRESHOLD,
DEFAULT_INPUT_OVERLAY_MOUSE_SWIPE_THRESHOLD,
"%.1f%%",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0.0, 10.0, 0.1, true, true);
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
#endif
break;
case SETTINGS_LIST_MENU:
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_MENU_SETTINGS),
parent_group);
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_IDX_PTR(list, list_info, MENU_ENUM_LABEL_MENU_SETTINGS);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_MENU_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
if (string_is_not_equal(settings->arrays.menu_driver, "rgui") &&
string_is_not_equal(settings->arrays.menu_driver, "ozone"))
{
CONFIG_PATH(
list, list_info,
settings->paths.path_menu_wallpaper,
sizeof(settings->paths.path_menu_wallpaper),
MENU_ENUM_LABEL_MENU_WALLPAPER,
MENU_ENUM_LABEL_VALUE_MENU_WALLPAPER,
settings->paths.directory_assets,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
MENU_SETTINGS_LIST_CURRENT_ADD_VALUES(list, list_info, "png");
CONFIG_FLOAT(
list, list_info,
&settings->floats.menu_wallpaper_opacity,
MENU_ENUM_LABEL_MENU_WALLPAPER_OPACITY,
MENU_ENUM_LABEL_VALUE_MENU_WALLPAPER_OPACITY,
DEFAULT_MENU_WALLPAPER_OPACITY,
"%.3f",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0.0, 1.0, 0.010, true, true);
}
if (string_is_not_equal(settings->arrays.menu_driver, "rgui") &&
string_is_not_equal(settings->arrays.menu_driver, "xmb"))
{
CONFIG_FLOAT(
list, list_info,
&settings->floats.menu_framebuffer_opacity,
MENU_ENUM_LABEL_MENU_FRAMEBUFFER_OPACITY,
MENU_ENUM_LABEL_VALUE_MENU_FRAMEBUFFER_OPACITY,
DEFAULT_MENU_FRAMEBUFFER_OPACITY,
"%.3f",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0.0, 1.0, 0.010, true, true);
}
if (string_is_equal(settings->arrays.menu_driver, "xmb"))
{
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_dynamic_wallpaper_enable,
MENU_ENUM_LABEL_DYNAMIC_WALLPAPER,
MENU_ENUM_LABEL_VALUE_DYNAMIC_WALLPAPER,
DEFAULT_MENU_DYNAMIC_WALLPAPER_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
}
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_pause_libretro,
MENU_ENUM_LABEL_PAUSE_LIBRETRO,
MENU_ENUM_LABEL_VALUE_PAUSE_LIBRETRO,
true,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_CMD_APPLY_AUTO
);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_MENU_PAUSE_LIBRETRO);
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_savestate_resume,
MENU_ENUM_LABEL_MENU_SAVESTATE_RESUME,
MENU_ENUM_LABEL_VALUE_MENU_SAVESTATE_RESUME,
DEFAULT_MENU_SAVESTATE_RESUME,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED
);
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_insert_disk_resume,
MENU_ENUM_LABEL_MENU_INSERT_DISK_RESUME,
MENU_ENUM_LABEL_VALUE_MENU_INSERT_DISK_RESUME,
DEFAULT_MENU_INSERT_DISK_RESUME,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED
);
CONFIG_UINT(
list, list_info,
&settings->uints.quit_on_close_content,
MENU_ENUM_LABEL_QUIT_ON_CLOSE_CONTENT,
MENU_ENUM_LABEL_VALUE_QUIT_ON_CLOSE_CONTENT,
DEFAULT_QUIT_ON_CLOSE_CONTENT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_quit_on_close_content;
menu_settings_list_current_add_range(list, list_info, 0, QUIT_ON_CLOSE_CONTENT_LAST-1, 1, true, true);
CONFIG_UINT(
list, list_info,
&settings->uints.menu_screensaver_timeout,
MENU_ENUM_LABEL_MENU_SCREENSAVER_TIMEOUT,
MENU_ENUM_LABEL_VALUE_MENU_SCREENSAVER_TIMEOUT,
DEFAULT_MENU_SCREENSAVER_TIMEOUT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint_special;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_menu_screensaver_timeout;
menu_settings_list_current_add_range(list, list_info, 0, 1800, 10, true, true);
#if (defined(HAVE_MATERIALUI) || defined(HAVE_XMB) || defined(HAVE_OZONE)) && !defined(_3DS)
if (string_is_equal(settings->arrays.menu_driver, "glui") ||
string_is_equal(settings->arrays.menu_driver, "xmb") ||
string_is_equal(settings->arrays.menu_driver, "ozone"))
{
CONFIG_UINT(
list, list_info,
&settings->uints.menu_screensaver_animation,
MENU_ENUM_LABEL_MENU_SCREENSAVER_ANIMATION,
MENU_ENUM_LABEL_VALUE_MENU_SCREENSAVER_ANIMATION,
DEFAULT_MENU_SCREENSAVER_ANIMATION,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].action_left = &setting_uint_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_uint_action_right_with_refresh;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_menu_screensaver_animation;
menu_settings_list_current_add_range(list, list_info, 0, MENU_SCREENSAVER_LAST-1, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
CONFIG_FLOAT(
list, list_info,
&settings->floats.menu_screensaver_animation_speed,
MENU_ENUM_LABEL_MENU_SCREENSAVER_ANIMATION_SPEED,
MENU_ENUM_LABEL_VALUE_MENU_SCREENSAVER_ANIMATION_SPEED,
DEFAULT_MENU_SCREENSAVER_ANIMATION_SPEED,
"%.1fx",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0.1, 10.0, 0.1, true, true);
}
#endif
#if defined(HAVE_XMB) || defined(HAVE_OZONE) || defined(HAVE_RGUI)
if (string_is_equal(settings->arrays.menu_driver, "xmb") ||
string_is_equal(settings->arrays.menu_driver, "ozone") ||
string_is_equal(settings->arrays.menu_driver, "rgui"))
{
CONFIG_UINT(
list, list_info,
&settings->uints.menu_remember_selection,
MENU_ENUM_LABEL_MENU_REMEMBER_SELECTION,
MENU_ENUM_LABEL_VALUE_MENU_REMEMBER_SELECTION,
DEFAULT_MENU_REMEMBER_SELECTION,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].action_left = &setting_uint_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_uint_action_right_with_refresh;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_menu_remember_selection;
menu_settings_list_current_add_range(list, list_info, 0, MENU_REMEMBER_SELECTION_LAST-1, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
}
#endif
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_mouse_enable,
MENU_ENUM_LABEL_MOUSE_ENABLE,
MENU_ENUM_LABEL_VALUE_MOUSE_ENABLE,
DEFAULT_MOUSE_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED
);
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_pointer_enable,
MENU_ENUM_LABEL_POINTER_ENABLE,
MENU_ENUM_LABEL_VALUE_POINTER_ENABLE,
DEFAULT_POINTER_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED
);
if (string_is_equal(settings->arrays.menu_driver, "rgui"))
{
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_rgui_border_filler_enable,
MENU_ENUM_LABEL_MENU_RGUI_BORDER_FILLER_ENABLE,
MENU_ENUM_LABEL_VALUE_MENU_RGUI_BORDER_FILLER_ENABLE,
true,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_rgui_background_filler_thickness_enable,
MENU_ENUM_LABEL_MENU_RGUI_BACKGROUND_FILLER_THICKNESS_ENABLE,
MENU_ENUM_LABEL_VALUE_MENU_RGUI_BACKGROUND_FILLER_THICKNESS_ENABLE,
true,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_rgui_border_filler_thickness_enable,
MENU_ENUM_LABEL_MENU_RGUI_BORDER_FILLER_THICKNESS_ENABLE,
MENU_ENUM_LABEL_VALUE_MENU_RGUI_BORDER_FILLER_THICKNESS_ENABLE,
true,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_rgui_full_width_layout,
MENU_ENUM_LABEL_MENU_RGUI_FULL_WIDTH_LAYOUT,
MENU_ENUM_LABEL_VALUE_MENU_RGUI_FULL_WIDTH_LAYOUT,
DEFAULT_RGUI_FULL_WIDTH_LAYOUT,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
if (video_driver_test_all_flags(GFX_CTX_FLAGS_MENU_FRAME_FILTERING))
{
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_linear_filter,
MENU_ENUM_LABEL_MENU_LINEAR_FILTER,
MENU_ENUM_LABEL_VALUE_MENU_LINEAR_FILTER,
true,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_UINT(
list, list_info,
&settings->uints.menu_rgui_internal_upscale_level,
MENU_ENUM_LABEL_MENU_RGUI_INTERNAL_UPSCALE_LEVEL,
MENU_ENUM_LABEL_VALUE_MENU_RGUI_INTERNAL_UPSCALE_LEVEL,
DEFAULT_RGUI_INTERNAL_UPSCALE_LEVEL,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_rgui_internal_upscale_level;
menu_settings_list_current_add_range(list, list_info, 0, RGUI_UPSCALE_LAST-1, 1, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
}
#if !defined(DINGUX)
CONFIG_UINT(
list, list_info,
&settings->uints.menu_rgui_aspect_ratio,
MENU_ENUM_LABEL_MENU_RGUI_ASPECT_RATIO,
MENU_ENUM_LABEL_VALUE_MENU_RGUI_ASPECT_RATIO,
DEFAULT_RGUI_ASPECT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_rgui_aspect_ratio;
menu_settings_list_current_add_range(list, list_info, 0, RGUI_ASPECT_RATIO_LAST-1, 1, true, true);
CONFIG_UINT(
list, list_info,
&settings->uints.menu_rgui_aspect_ratio_lock,
MENU_ENUM_LABEL_MENU_RGUI_ASPECT_RATIO_LOCK,
MENU_ENUM_LABEL_VALUE_MENU_RGUI_ASPECT_RATIO_LOCK,
DEFAULT_RGUI_ASPECT_LOCK,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_rgui_aspect_ratio_lock;
#if defined(GEKKO)
menu_settings_list_current_add_range(list, list_info, 0, RGUI_ASPECT_RATIO_LOCK_LAST-3, 1, true, true);
#else
menu_settings_list_current_add_range(list, list_info, 0, RGUI_ASPECT_RATIO_LOCK_LAST-1, 1, true, true);
#endif
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
#endif
CONFIG_UINT(
list, list_info,
&settings->uints.menu_rgui_color_theme,
MENU_ENUM_LABEL_RGUI_MENU_COLOR_THEME,
MENU_ENUM_LABEL_VALUE_RGUI_MENU_COLOR_THEME,
DEFAULT_RGUI_COLOR_THEME,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].action_left = &setting_uint_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_uint_action_right_with_refresh;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_rgui_menu_color_theme;
menu_settings_list_current_add_range(list, list_info, 0, RGUI_THEME_LAST-1, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
CONFIG_PATH(
list, list_info,
settings->paths.path_rgui_theme_preset,
sizeof(settings->paths.path_rgui_theme_preset),
MENU_ENUM_LABEL_RGUI_MENU_THEME_PRESET,
MENU_ENUM_LABEL_VALUE_RGUI_MENU_THEME_PRESET,
settings->paths.directory_assets,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
MENU_SETTINGS_LIST_CURRENT_ADD_VALUES(list, list_info, "cfg");
/* ps2 and sdl_dingux/sdl_rs90 gfx drivers do
* not support menu framebuffer transparency */
if (!string_is_equal(settings->arrays.video_driver, "ps2") &&
!string_is_equal(settings->arrays.video_driver, "sdl_dingux") &&
!string_is_equal(settings->arrays.video_driver, "sdl_rs90"))
{
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_rgui_transparency,
MENU_ENUM_LABEL_MENU_RGUI_TRANSPARENCY,
MENU_ENUM_LABEL_VALUE_MENU_RGUI_TRANSPARENCY,
DEFAULT_RGUI_TRANSPARENCY,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
}
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_rgui_shadows,
MENU_ENUM_LABEL_MENU_RGUI_SHADOWS,
MENU_ENUM_LABEL_VALUE_MENU_RGUI_SHADOWS,
DEFAULT_RGUI_SHADOWS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_UINT(
list, list_info,
&settings->uints.menu_rgui_particle_effect,
MENU_ENUM_LABEL_MENU_RGUI_PARTICLE_EFFECT,
MENU_ENUM_LABEL_VALUE_MENU_RGUI_PARTICLE_EFFECT,
DEFAULT_RGUI_PARTICLE_EFFECT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].action_left = &setting_uint_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_uint_action_right_with_refresh;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_rgui_particle_effect;
menu_settings_list_current_add_range(list, list_info, 0, RGUI_PARTICLE_EFFECT_LAST-1, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
CONFIG_FLOAT(
list, list_info,
&settings->floats.menu_rgui_particle_effect_speed,
MENU_ENUM_LABEL_MENU_RGUI_PARTICLE_EFFECT_SPEED,
MENU_ENUM_LABEL_VALUE_MENU_RGUI_PARTICLE_EFFECT_SPEED,
DEFAULT_RGUI_PARTICLE_EFFECT_SPEED,
"%.1fx",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0.1, 10.0, 0.1, true, true);
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_rgui_particle_effect_screensaver,
MENU_ENUM_LABEL_MENU_RGUI_PARTICLE_EFFECT_SCREENSAVER,
MENU_ENUM_LABEL_VALUE_MENU_RGUI_PARTICLE_EFFECT_SCREENSAVER,
DEFAULT_RGUI_PARTICLE_EFFECT_SCREENSAVER,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_rgui_extended_ascii,
MENU_ENUM_LABEL_MENU_RGUI_EXTENDED_ASCII,
MENU_ENUM_LABEL_VALUE_MENU_RGUI_EXTENDED_ASCII,
DEFAULT_RGUI_EXTENDED_ASCII,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_rgui_switch_icons,
MENU_ENUM_LABEL_MENU_RGUI_SWITCH_ICONS,
MENU_ENUM_LABEL_VALUE_MENU_RGUI_SWITCH_ICONS,
DEFAULT_RGUI_SWITCH_ICONS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
}
#ifdef HAVE_XMB
if (string_is_equal(settings->arrays.menu_driver, "xmb"))
{
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_horizontal_animation,
MENU_ENUM_LABEL_MENU_HORIZONTAL_ANIMATION,
MENU_ENUM_LABEL_VALUE_MENU_HORIZONTAL_ANIMATION,
DEFAULT_MENU_HORIZONTAL_ANIMATION,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED
);
#ifdef RARCH_MOBILE
/* We don't want mobile users being able to switch this off. */
(*list)[list_info->index - 1].action_left = NULL;
(*list)[list_info->index - 1].action_right = NULL;
(*list)[list_info->index - 1].action_start = NULL;
#else
(*list)[list_info->index - 1].action_ok = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = setting_bool_action_right_with_refresh;
#endif
CONFIG_UINT(
list, list_info,
&settings->uints.menu_xmb_animation_horizontal_highlight,
MENU_ENUM_LABEL_MENU_XMB_ANIMATION_HORIZONTAL_HIGHLIGHT,
MENU_ENUM_LABEL_VALUE_MENU_XMB_ANIMATION_HORIZONTAL_HIGHLIGHT,
DEFAULT_XMB_ANIMATION,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_menu_xmb_animation_horizontal_highlight;
menu_settings_list_current_add_range(list, list_info, 0, 2, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_RADIO_BUTTONS;
CONFIG_UINT(
list, list_info,
&settings->uints.menu_xmb_animation_move_up_down,
MENU_ENUM_LABEL_MENU_XMB_ANIMATION_MOVE_UP_DOWN,
MENU_ENUM_LABEL_VALUE_MENU_XMB_ANIMATION_MOVE_UP_DOWN,
DEFAULT_XMB_ANIMATION,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_menu_xmb_animation_move_up_down;
menu_settings_list_current_add_range(list, list_info, 0, 2, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_RADIO_BUTTONS;
CONFIG_UINT(
list, list_info,
&settings->uints.menu_xmb_animation_opening_main_menu,
MENU_ENUM_LABEL_MENU_XMB_ANIMATION_OPENING_MAIN_MENU,
MENU_ENUM_LABEL_VALUE_MENU_XMB_ANIMATION_OPENING_MAIN_MENU,
DEFAULT_XMB_ANIMATION,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_menu_xmb_animation_opening_main_menu;
menu_settings_list_current_add_range(list, list_info, 0, 3, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_RADIO_BUTTONS;
}
#endif
CONFIG_UINT(
list, list_info,
&settings->uints.menu_ticker_type,
MENU_ENUM_LABEL_MENU_TICKER_TYPE,
MENU_ENUM_LABEL_VALUE_MENU_TICKER_TYPE,
DEFAULT_MENU_TICKER_TYPE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_menu_ticker_type;
menu_settings_list_current_add_range(list, list_info, 0, TICKER_TYPE_LAST-1, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_RADIO_BUTTONS;
CONFIG_FLOAT(
list, list_info,
&settings->floats.menu_ticker_speed,
MENU_ENUM_LABEL_MENU_TICKER_SPEED,
MENU_ENUM_LABEL_VALUE_MENU_TICKER_SPEED,
DEFAULT_MENU_TICKER_SPEED,
"%.1fx",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0.1, 10.0, 0.1, true, true);
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_ticker_smooth,
MENU_ENUM_LABEL_MENU_TICKER_SMOOTH,
MENU_ENUM_LABEL_VALUE_MENU_TICKER_SMOOTH,
DEFAULT_MENU_TICKER_SMOOTH,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
END_SUB_GROUP(list, list_info, parent_group);
START_SUB_GROUP(list, list_info, "Navigation", &group_info, &subgroup_info, parent_group);
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_navigation_wraparound_enable,
MENU_ENUM_LABEL_NAVIGATION_WRAPAROUND,
MENU_ENUM_LABEL_VALUE_NAVIGATION_WRAPAROUND,
true,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED
);
END_SUB_GROUP(list, list_info, parent_group);
START_SUB_GROUP(list, list_info, "Settings View", &group_info, &subgroup_info, parent_group);
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_show_advanced_settings,
MENU_ENUM_LABEL_SHOW_ADVANCED_SETTINGS,
MENU_ENUM_LABEL_VALUE_SHOW_ADVANCED_SETTINGS,
DEFAULT_SHOW_ADVANCED_SETTINGS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
if (string_is_equal(settings->arrays.menu_driver, "xmb") || string_is_equal(settings->arrays.menu_driver, "ozone"))
{
CONFIG_BOOL(
list, list_info,
&settings->bools.kiosk_mode_enable,
MENU_ENUM_LABEL_MENU_ENABLE_KIOSK_MODE,
MENU_ENUM_LABEL_VALUE_MENU_ENABLE_KIOSK_MODE,
DEFAULT_KIOSK_MODE_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].action_ok = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = setting_bool_action_right_with_refresh;
CONFIG_STRING(
list, list_info,
settings->paths.kiosk_mode_password,
sizeof(settings->paths.kiosk_mode_password),
MENU_ENUM_LABEL_MENU_KIOSK_MODE_PASSWORD,
MENU_ENUM_LABEL_VALUE_MENU_KIOSK_MODE_PASSWORD,
"",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_PASSWORD_LINE_EDIT;
(*list)[list_info->index - 1].action_start = setting_generic_action_start_default;
}
#ifdef HAVE_THREADS
CONFIG_BOOL(
list, list_info,
&settings->bools.threaded_data_runloop_enable,
MENU_ENUM_LABEL_THREADED_DATA_RUNLOOP_ENABLE,
MENU_ENUM_LABEL_VALUE_THREADED_DATA_RUNLOOP_ENABLE,
DEFAULT_THREADED_DATA_RUNLOOP_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED
);
#endif
END_SUB_GROUP(list, list_info, parent_group);
START_SUB_GROUP(list, list_info, "Display", &group_info, &subgroup_info, parent_group);
/* > MaterialUI, XMB and Ozone all support menu scaling */
if (string_is_equal(settings->arrays.menu_driver, "glui") ||
string_is_equal(settings->arrays.menu_driver, "xmb") ||
string_is_equal(settings->arrays.menu_driver, "ozone"))
{
CONFIG_FLOAT(
list, list_info,
&settings->floats.menu_scale_factor,
MENU_ENUM_LABEL_MENU_SCALE_FACTOR,
MENU_ENUM_LABEL_VALUE_MENU_SCALE_FACTOR,
DEFAULT_MENU_SCALE_FACTOR,
"%.2fx",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0.2, 5.0, 0.01, true, true);
}
#ifdef HAVE_XMB
if (string_is_equal(settings->arrays.menu_driver, "xmb"))
{
/* only XMB uses these values, don't show
* them on other drivers. */
CONFIG_UINT(
list, list_info,
&settings->uints.menu_xmb_alpha_factor,
MENU_ENUM_LABEL_XMB_ALPHA_FACTOR,
MENU_ENUM_LABEL_VALUE_XMB_ALPHA_FACTOR,
DEFAULT_XMB_ALPHA_FACTOR,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0, 100, 1, true, true);
CONFIG_UINT(
list, list_info,
&settings->uints.menu_xmb_vertical_fade_factor,
MENU_ENUM_LABEL_MENU_XMB_VERTICAL_FADE_FACTOR,
MENU_ENUM_LABEL_VALUE_MENU_XMB_VERTICAL_FADE_FACTOR,
DEFAULT_XMB_VERTICAL_FADE_FACTOR,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].action_left = &setting_uint_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_uint_action_right_with_refresh;
menu_settings_list_current_add_range(list, list_info, 0, 500, 1, true, true);
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_xmb_show_title_header,
MENU_ENUM_LABEL_MENU_XMB_SHOW_TITLE_HEADER,
MENU_ENUM_LABEL_VALUE_MENU_XMB_SHOW_TITLE_HEADER,
DEFAULT_XMB_SHOW_TITLE_HEADER,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_INT(
list, list_info,
&settings->ints.menu_xmb_title_margin,
MENU_ENUM_LABEL_MENU_XMB_TITLE_MARGIN,
MENU_ENUM_LABEL_VALUE_MENU_XMB_TITLE_MARGIN,
DEFAULT_XMB_TITLE_MARGIN,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].offset_by = -MAXIMUM_XMB_TITLE_MARGIN;
menu_settings_list_current_add_range(list, list_info, -MAXIMUM_XMB_TITLE_MARGIN, MAXIMUM_XMB_TITLE_MARGIN, 1, true, true);
CONFIG_INT(
list, list_info,
&settings->ints.menu_xmb_title_margin_horizontal_offset,
MENU_ENUM_LABEL_MENU_XMB_TITLE_MARGIN_HORIZONTAL_OFFSET,
MENU_ENUM_LABEL_VALUE_MENU_XMB_TITLE_MARGIN_HORIZONTAL_OFFSET,
DEFAULT_XMB_TITLE_MARGIN_HORIZONTAL_OFFSET,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].offset_by = -MAXIMUM_XMB_TITLE_MARGIN;
menu_settings_list_current_add_range(list, list_info, -MAXIMUM_XMB_TITLE_MARGIN, MAXIMUM_XMB_TITLE_MARGIN, 1, true, true);
CONFIG_PATH(
list, list_info,
settings->paths.path_menu_xmb_font,
sizeof(settings->paths.path_menu_xmb_font),
MENU_ENUM_LABEL_XMB_FONT,
MENU_ENUM_LABEL_VALUE_XMB_FONT,
settings->paths.directory_assets,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].get_string_representation = &setting_get_string_representation_video_font_path;
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_FONT_SELECTOR;
MENU_SETTINGS_LIST_CURRENT_ADD_VALUES(list, list_info, "ttf");
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_REINIT);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_UINT(
list, list_info,
&settings->uints.menu_font_color_red,
MENU_ENUM_LABEL_MENU_FONT_COLOR_RED,
MENU_ENUM_LABEL_VALUE_MENU_FONT_COLOR_RED,
DEFAULT_MENU_FONT_COLOR_RED,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0, 255, 1, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
CONFIG_UINT(
list, list_info,
&settings->uints.menu_font_color_green,
MENU_ENUM_LABEL_MENU_FONT_COLOR_GREEN,
MENU_ENUM_LABEL_VALUE_MENU_FONT_COLOR_GREEN,
DEFAULT_MENU_FONT_COLOR_GREEN,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0, 255, 1, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
CONFIG_UINT(
list, list_info,
&settings->uints.menu_font_color_blue,
MENU_ENUM_LABEL_MENU_FONT_COLOR_BLUE,
MENU_ENUM_LABEL_VALUE_MENU_FONT_COLOR_BLUE,
DEFAULT_MENU_FONT_COLOR_BLUE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0, 255, 1, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
CONFIG_UINT(
list, list_info,
&settings->uints.menu_xmb_layout,
MENU_ENUM_LABEL_XMB_LAYOUT,
MENU_ENUM_LABEL_VALUE_XMB_LAYOUT,
DEFAULT_XMB_MENU_LAYOUT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_xmb_layout;
menu_settings_list_current_add_range(list, list_info, 0, 2, 1, true, true);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_REINIT);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
CONFIG_UINT(
list, list_info,
&settings->uints.menu_xmb_theme,
MENU_ENUM_LABEL_XMB_THEME,
MENU_ENUM_LABEL_VALUE_XMB_THEME,
DEFAULT_XMB_ICON_THEME,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_xmb_icon_theme;
menu_settings_list_current_add_range(list, list_info, 0, XMB_ICON_THEME_LAST - 1, 1, true, true);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_REINIT);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_xmb_switch_icons,
MENU_ENUM_LABEL_XMB_SWITCH_ICONS,
MENU_ENUM_LABEL_VALUE_XMB_SWITCH_ICONS,
DEFAULT_XMB_SWITCH_ICONS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_xmb_shadows_enable,
MENU_ENUM_LABEL_XMB_SHADOWS_ENABLE,
MENU_ENUM_LABEL_VALUE_XMB_SHADOWS_ENABLE,
DEFAULT_XMB_SHADOWS_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
#ifdef HAVE_SHADERPIPELINE
if (video_shader_any_supported())
{
CONFIG_UINT(
list, list_info,
&settings->uints.menu_xmb_shader_pipeline,
MENU_ENUM_LABEL_XMB_RIBBON_ENABLE,
MENU_ENUM_LABEL_VALUE_XMB_RIBBON_ENABLE,
DEFAULT_MENU_SHADER_PIPELINE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_xmb_shader_pipeline;
menu_settings_list_current_add_range(list, list_info, 0, XMB_SHADER_PIPELINE_LAST-1, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
}
#endif
#endif
CONFIG_UINT(
list, list_info,
&settings->uints.menu_xmb_color_theme,
MENU_ENUM_LABEL_XMB_MENU_COLOR_THEME,
MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME,
DEFAULT_XMB_THEME,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_xmb_menu_color_theme;
menu_settings_list_current_add_range(list, list_info, 0, XMB_THEME_LAST-1, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
}
#endif
if (string_is_equal(settings->arrays.menu_driver, "ozone"))
{
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_use_preferred_system_color_theme,
MENU_ENUM_LABEL_MENU_USE_PREFERRED_SYSTEM_COLOR_THEME,
MENU_ENUM_LABEL_VALUE_MENU_USE_PREFERRED_SYSTEM_COLOR_THEME,
DEFAULT_MENU_USE_PREFERRED_SYSTEM_COLOR_THEME,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].action_ok = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_bool_action_right_with_refresh;
}
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_show_load_core,
MENU_ENUM_LABEL_MENU_SHOW_LOAD_CORE,
MENU_ENUM_LABEL_VALUE_MENU_SHOW_LOAD_CORE,
DEFAULT_MENU_SHOW_LOAD_CORE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_show_load_content,
MENU_ENUM_LABEL_MENU_SHOW_LOAD_CONTENT,
MENU_ENUM_LABEL_VALUE_MENU_SHOW_LOAD_CONTENT,
DEFAULT_MENU_SHOW_LOAD_CONTENT,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#ifdef HAVE_CDROM
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_show_load_disc,
MENU_ENUM_LABEL_MENU_SHOW_LOAD_DISC,
MENU_ENUM_LABEL_VALUE_MENU_SHOW_LOAD_DISC,
DEFAULT_MENU_SHOW_LOAD_DISC,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_show_dump_disc,
MENU_ENUM_LABEL_MENU_SHOW_DUMP_DISC,
MENU_ENUM_LABEL_VALUE_MENU_SHOW_DUMP_DISC,
DEFAULT_MENU_SHOW_DUMP_DISC,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#ifdef HAVE_LAKKA
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_show_eject_disc,
MENU_ENUM_LABEL_MENU_SHOW_EJECT_DISC,
MENU_ENUM_LABEL_VALUE_MENU_SHOW_EJECT_DISC,
DEFAULT_MENU_SHOW_EJECT_DISC,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#endif /* HAVE_LAKKA */
#endif
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_show_information,
MENU_ENUM_LABEL_MENU_SHOW_INFORMATION,
MENU_ENUM_LABEL_VALUE_MENU_SHOW_INFORMATION,
DEFAULT_MENU_SHOW_INFORMATION,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_show_configurations,
MENU_ENUM_LABEL_MENU_SHOW_CONFIGURATIONS,
MENU_ENUM_LABEL_VALUE_MENU_SHOW_CONFIGURATIONS,
DEFAULT_MENU_SHOW_CONFIGURATIONS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_LAKKA_ADVANCED);
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_show_overlays,
MENU_ENUM_LABEL_CONTENT_SHOW_OVERLAYS,
MENU_ENUM_LABEL_VALUE_CONTENT_SHOW_OVERLAYS,
DEFAULT_QUICK_MENU_SHOW_OVERLAYS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_LAKKA_ADVANCED);
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_show_latency,
MENU_ENUM_LABEL_CONTENT_SHOW_LATENCY,
MENU_ENUM_LABEL_VALUE_CONTENT_SHOW_LATENCY,
DEFAULT_QUICK_MENU_SHOW_LATENCY,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_LAKKA_ADVANCED);
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_show_rewind,
MENU_ENUM_LABEL_CONTENT_SHOW_REWIND,
MENU_ENUM_LABEL_VALUE_CONTENT_SHOW_REWIND,
DEFAULT_QUICK_MENU_SHOW_REWIND,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_LAKKA_ADVANCED);
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_show_help,
MENU_ENUM_LABEL_MENU_SHOW_HELP,
MENU_ENUM_LABEL_VALUE_MENU_SHOW_HELP,
DEFAULT_MENU_SHOW_HELP,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_LAKKA_ADVANCED);
#ifdef HAVE_LAKKA
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_show_quit_retroarch,
MENU_ENUM_LABEL_MENU_SHOW_QUIT_RETROARCH,
MENU_ENUM_LABEL_VALUE_MENU_SHOW_RESTART_RETROARCH,
DEFAULT_MENU_SHOW_RESTART,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#else
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_show_quit_retroarch,
MENU_ENUM_LABEL_MENU_SHOW_QUIT_RETROARCH,
MENU_ENUM_LABEL_VALUE_MENU_SHOW_QUIT_RETROARCH,
DEFAULT_MENU_SHOW_QUIT,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#endif
#if defined(HAVE_LAKKA) || defined(HAVE_ODROIDGO2)
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_show_reboot,
MENU_ENUM_LABEL_MENU_SHOW_REBOOT,
MENU_ENUM_LABEL_VALUE_MENU_SHOW_REBOOT,
DEFAULT_MENU_SHOW_REBOOT,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_show_shutdown,
MENU_ENUM_LABEL_MENU_SHOW_SHUTDOWN,
MENU_ENUM_LABEL_VALUE_MENU_SHOW_SHUTDOWN,
DEFAULT_MENU_SHOW_SHUTDOWN,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#else
#if !defined(IOS)
if (frontend_driver_has_fork())
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_show_restart_retroarch,
MENU_ENUM_LABEL_MENU_SHOW_RESTART_RETROARCH,
MENU_ENUM_LABEL_VALUE_MENU_SHOW_RESTART_RETROARCH,
DEFAULT_MENU_SHOW_RESTART,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#endif
#endif
#if defined(HAVE_XMB) || defined(HAVE_OZONE)
if (string_is_equal(settings->arrays.menu_driver, "xmb") || string_is_equal(settings->arrays.menu_driver, "ozone"))
{
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_content_show_settings,
MENU_ENUM_LABEL_CONTENT_SHOW_SETTINGS,
MENU_ENUM_LABEL_VALUE_CONTENT_SHOW_SETTINGS,
DEFAULT_CONTENT_SHOW_SETTINGS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_STRING(
list, list_info,
settings->paths.menu_content_show_settings_password,
sizeof(settings->paths.menu_content_show_settings_password),
MENU_ENUM_LABEL_CONTENT_SHOW_SETTINGS_PASSWORD,
MENU_ENUM_LABEL_VALUE_CONTENT_SHOW_SETTINGS_PASSWORD,
"",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT | SD_FLAG_LAKKA_ADVANCED);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_PASSWORD_LINE_EDIT;
(*list)[list_info->index - 1].action_start = setting_generic_action_start_default;
}
#endif
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_content_show_favorites,
MENU_ENUM_LABEL_CONTENT_SHOW_FAVORITES,
MENU_ENUM_LABEL_VALUE_CONTENT_SHOW_FAVORITES,
DEFAULT_CONTENT_SHOW_FAVORITES,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#ifdef HAVE_IMAGEVIEWER
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_content_show_images,
MENU_ENUM_LABEL_CONTENT_SHOW_IMAGES,
MENU_ENUM_LABEL_VALUE_CONTENT_SHOW_IMAGES,
DEFAULT_CONTENT_SHOW_IMAGES,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#endif
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_content_show_music,
MENU_ENUM_LABEL_CONTENT_SHOW_MUSIC,
MENU_ENUM_LABEL_VALUE_CONTENT_SHOW_MUSIC,
DEFAULT_CONTENT_SHOW_MUSIC,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#if defined(HAVE_FFMPEG) || defined(HAVE_MPV)
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_content_show_video,
MENU_ENUM_LABEL_CONTENT_SHOW_VIDEO,
MENU_ENUM_LABEL_VALUE_CONTENT_SHOW_VIDEO,
DEFAULT_CONTENT_SHOW_VIDEO,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#endif
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_content_show_history,
MENU_ENUM_LABEL_CONTENT_SHOW_HISTORY,
MENU_ENUM_LABEL_VALUE_CONTENT_SHOW_HISTORY,
DEFAULT_CONTENT_SHOW_HISTORY,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#ifdef HAVE_NETWORKING
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_content_show_netplay,
MENU_ENUM_LABEL_CONTENT_SHOW_NETPLAY,
MENU_ENUM_LABEL_VALUE_CONTENT_SHOW_NETPLAY,
DEFAULT_CONTENT_SHOW_NETPLAY,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#endif
#if defined(HAVE_XMB) || defined(HAVE_OZONE)
if (string_is_equal(settings->arrays.menu_driver, "xmb") ||
string_is_equal(settings->arrays.menu_driver, "ozone"))
{
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_content_show_add,
MENU_ENUM_LABEL_CONTENT_SHOW_ADD,
MENU_ENUM_LABEL_VALUE_CONTENT_SHOW_ADD,
DEFAULT_MENU_CONTENT_SHOW_ADD,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
}
else
#endif
{
CONFIG_UINT(
list, list_info,
&settings->uints.menu_content_show_add_entry,
MENU_ENUM_LABEL_CONTENT_SHOW_ADD_ENTRY,
MENU_ENUM_LABEL_VALUE_CONTENT_SHOW_ADD_ENTRY,
DEFAULT_MENU_CONTENT_SHOW_ADD_ENTRY,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_menu_add_content_entry_display_type;
menu_settings_list_current_add_range(list, list_info, 0, MENU_ADD_CONTENT_ENTRY_DISPLAY_LAST-1, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
}
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_content_show_playlists,
MENU_ENUM_LABEL_CONTENT_SHOW_PLAYLISTS,
MENU_ENUM_LABEL_VALUE_CONTENT_SHOW_PLAYLISTS,
DEFAULT_CONTENT_SHOW_PLAYLISTS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#if defined(HAVE_LIBRETRODB)
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_content_show_explore,
MENU_ENUM_LABEL_CONTENT_SHOW_EXPLORE,
MENU_ENUM_LABEL_VALUE_CONTENT_SHOW_EXPLORE,
DEFAULT_MENU_CONTENT_SHOW_EXPLORE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#endif
CONFIG_UINT(
list, list_info,
&settings->uints.menu_content_show_contentless_cores,
MENU_ENUM_LABEL_CONTENT_SHOW_CONTENTLESS_CORES,
MENU_ENUM_LABEL_VALUE_CONTENT_SHOW_CONTENTLESS_CORES,
DEFAULT_MENU_CONTENT_SHOW_CONTENTLESS_CORES,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_menu_contentless_cores_display_type;
menu_settings_list_current_add_range(list, list_info, 0, MENU_CONTENTLESS_CORES_DISPLAY_LAST-1, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
#ifdef HAVE_MATERIALUI
if (string_is_equal(settings->arrays.menu_driver, "glui"))
{
/* only MaterialUI uses these values, don't show
* them on other drivers. */
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_materialui_icons_enable,
MENU_ENUM_LABEL_MATERIALUI_ICONS_ENABLE,
MENU_ENUM_LABEL_VALUE_MATERIALUI_ICONS_ENABLE,
DEFAULT_MATERIALUI_ICONS_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED);
(*list)[list_info->index - 1].action_ok = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_bool_action_right_with_refresh;
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_materialui_switch_icons,
MENU_ENUM_LABEL_MATERIALUI_SWITCH_ICONS,
MENU_ENUM_LABEL_VALUE_MATERIALUI_SWITCH_ICONS,
DEFAULT_MATERIALUI_SWITCH_ICONS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_materialui_playlist_icons_enable,
MENU_ENUM_LABEL_MATERIALUI_PLAYLIST_ICONS_ENABLE,
MENU_ENUM_LABEL_VALUE_MATERIALUI_PLAYLIST_ICONS_ENABLE,
DEFAULT_MATERIALUI_PLAYLIST_ICONS_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_UINT(
list, list_info,
&settings->uints.menu_materialui_color_theme,
MENU_ENUM_LABEL_MATERIALUI_MENU_COLOR_THEME,
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_COLOR_THEME,
DEFAULT_MATERIALUI_THEME,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_materialui_menu_color_theme;
menu_settings_list_current_add_range(list, list_info, 0, MATERIALUI_THEME_LAST-1, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
CONFIG_UINT(
list, list_info,
&settings->uints.menu_materialui_transition_animation,
MENU_ENUM_LABEL_MATERIALUI_MENU_TRANSITION_ANIMATION,
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_TRANSITION_ANIMATION,
DEFAULT_MATERIALUI_TRANSITION_ANIM,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_materialui_menu_transition_animation;
menu_settings_list_current_add_range(list, list_info, 0, MATERIALUI_TRANSITION_ANIM_LAST-1, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
CONFIG_UINT(
list, list_info,
&settings->uints.menu_materialui_landscape_layout_optimization,
MENU_ENUM_LABEL_MATERIALUI_LANDSCAPE_LAYOUT_OPTIMIZATION,
MENU_ENUM_LABEL_VALUE_MATERIALUI_LANDSCAPE_LAYOUT_OPTIMIZATION,
DEFAULT_MATERIALUI_LANDSCAPE_LAYOUT_OPTIMIZATION,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_materialui_landscape_layout_optimization;
menu_settings_list_current_add_range(list, list_info, 0, MATERIALUI_LANDSCAPE_LAYOUT_OPTIMIZATION_LAST-1, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_materialui_show_nav_bar,
MENU_ENUM_LABEL_MATERIALUI_SHOW_NAV_BAR,
MENU_ENUM_LABEL_VALUE_MATERIALUI_SHOW_NAV_BAR,
DEFAULT_MATERIALUI_SHOW_NAV_BAR,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].action_ok = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_bool_action_right_with_refresh;
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_materialui_auto_rotate_nav_bar,
MENU_ENUM_LABEL_MATERIALUI_AUTO_ROTATE_NAV_BAR,
MENU_ENUM_LABEL_VALUE_MATERIALUI_AUTO_ROTATE_NAV_BAR,
DEFAULT_MATERIALUI_AUTO_ROTATE_NAV_BAR,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_UINT(
list, list_info,
&settings->uints.menu_materialui_thumbnail_view_portrait,
MENU_ENUM_LABEL_MATERIALUI_MENU_THUMBNAIL_VIEW_PORTRAIT,
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_THUMBNAIL_VIEW_PORTRAIT,
DEFAULT_MATERIALUI_THUMBNAIL_VIEW_PORTRAIT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_materialui_menu_thumbnail_view_portrait;
menu_settings_list_current_add_range(list, list_info, 0, MATERIALUI_THUMBNAIL_VIEW_PORTRAIT_LAST-1, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
CONFIG_UINT(
list, list_info,
&settings->uints.menu_materialui_thumbnail_view_landscape,
MENU_ENUM_LABEL_MATERIALUI_MENU_THUMBNAIL_VIEW_LANDSCAPE,
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_THUMBNAIL_VIEW_LANDSCAPE,
DEFAULT_MATERIALUI_THUMBNAIL_VIEW_LANDSCAPE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_materialui_menu_thumbnail_view_landscape;
menu_settings_list_current_add_range(list, list_info, 0, MATERIALUI_THUMBNAIL_VIEW_LANDSCAPE_LAST-1, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_materialui_dual_thumbnail_list_view_enable,
MENU_ENUM_LABEL_MATERIALUI_DUAL_THUMBNAIL_LIST_VIEW_ENABLE,
MENU_ENUM_LABEL_VALUE_MATERIALUI_DUAL_THUMBNAIL_LIST_VIEW_ENABLE,
DEFAULT_MATERIALUI_DUAL_THUMBNAIL_LIST_VIEW_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_materialui_thumbnail_background_enable,
MENU_ENUM_LABEL_MATERIALUI_THUMBNAIL_BACKGROUND_ENABLE,
MENU_ENUM_LABEL_VALUE_MATERIALUI_THUMBNAIL_BACKGROUND_ENABLE,
DEFAULT_MATERIALUI_THUMBNAIL_BACKGROUND_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
/* TODO: These should be removed entirely, but just
* comment out for now in case users complain...
CONFIG_FLOAT(
list, list_info,
&settings->floats.menu_header_opacity,
MENU_ENUM_LABEL_MATERIALUI_MENU_HEADER_OPACITY,
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_HEADER_OPACITY,
DEFAULT_MENU_HEADER_OPACITY,
"%.3f",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0.0, 1.0, 0.010, true, true);
CONFIG_FLOAT(
list, list_info,
&settings->floats.menu_footer_opacity,
MENU_ENUM_LABEL_MATERIALUI_MENU_FOOTER_OPACITY,
MENU_ENUM_LABEL_VALUE_MATERIALUI_MENU_FOOTER_OPACITY,
DEFAULT_MENU_FOOTER_OPACITY,
"%.3f",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0.0, 1.0, 0.010, true, true);
(*list)[list_info->index - 1].ui_type
= ST_UI_TYPE_FLOAT_SLIDER_AND_SPINBOX;
*/
}
#endif
#ifdef HAVE_OZONE
if (string_is_equal(settings->arrays.menu_driver, "ozone"))
{
CONFIG_UINT(
list, list_info,
&settings->uints.menu_ozone_color_theme,
MENU_ENUM_LABEL_OZONE_MENU_COLOR_THEME,
MENU_ENUM_LABEL_VALUE_OZONE_MENU_COLOR_THEME,
DEFAULT_OZONE_COLOR_THEME,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_ozone_menu_color_theme;
menu_settings_list_current_add_range(list, list_info, 0, OZONE_COLOR_THEME_LAST-1, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
CONFIG_BOOL(
list, list_info,
&settings->bools.ozone_collapse_sidebar,
MENU_ENUM_LABEL_OZONE_COLLAPSE_SIDEBAR,
MENU_ENUM_LABEL_VALUE_OZONE_COLLAPSE_SIDEBAR,
DEFAULT_OZONE_COLLAPSE_SIDEBAR,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.ozone_scroll_content_metadata,
MENU_ENUM_LABEL_OZONE_SCROLL_CONTENT_METADATA,
MENU_ENUM_LABEL_VALUE_OZONE_SCROLL_CONTENT_METADATA,
DEFAULT_OZONE_SCROLL_CONTENT_METADATA,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_FLOAT(
list, list_info,
&settings->floats.ozone_thumbnail_scale_factor,
MENU_ENUM_LABEL_OZONE_THUMBNAIL_SCALE_FACTOR,
MENU_ENUM_LABEL_VALUE_OZONE_THUMBNAIL_SCALE_FACTOR,
DEFAULT_OZONE_THUMBNAIL_SCALE_FACTOR,
"%.2fx",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 1.0, 2.0, 0.05, true, true);
}
#endif
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_show_start_screen,
MENU_ENUM_LABEL_RGUI_SHOW_START_SCREEN,
MENU_ENUM_LABEL_VALUE_RGUI_SHOW_START_SCREEN,
DEFAULT_MENU_SHOW_START_SCREEN,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED);
if (string_is_equal(settings->arrays.menu_driver, "rgui"))
{
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_rgui_inline_thumbnails,
MENU_ENUM_LABEL_MENU_RGUI_INLINE_THUMBNAILS,
MENU_ENUM_LABEL_VALUE_MENU_RGUI_INLINE_THUMBNAILS,
DEFAULT_RGUI_INLINE_THUMBNAILS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_rgui_swap_thumbnails,
MENU_ENUM_LABEL_MENU_RGUI_SWAP_THUMBNAILS,
MENU_ENUM_LABEL_VALUE_MENU_RGUI_SWAP_THUMBNAILS,
DEFAULT_RGUI_SWAP_THUMBNAILS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
}
if (string_is_equal(settings->arrays.menu_driver, "xmb") ||
string_is_equal(settings->arrays.menu_driver, "ozone") ||
string_is_equal(settings->arrays.menu_driver, "rgui") ||
string_is_equal(settings->arrays.menu_driver, "glui"))
{
enum msg_hash_enums thumbnails_label_value;
enum msg_hash_enums left_thumbnails_label_value;
if (string_is_equal(settings->arrays.menu_driver, "rgui"))
{
thumbnails_label_value = MENU_ENUM_LABEL_VALUE_THUMBNAILS_RGUI;
left_thumbnails_label_value = MENU_ENUM_LABEL_VALUE_LEFT_THUMBNAILS_RGUI;
}
else if (string_is_equal(settings->arrays.menu_driver, "ozone"))
{
thumbnails_label_value = MENU_ENUM_LABEL_VALUE_THUMBNAILS;
left_thumbnails_label_value = MENU_ENUM_LABEL_VALUE_LEFT_THUMBNAILS_OZONE;
}
else if (string_is_equal(settings->arrays.menu_driver, "glui"))
{
thumbnails_label_value = MENU_ENUM_LABEL_VALUE_THUMBNAILS_MATERIALUI;
left_thumbnails_label_value = MENU_ENUM_LABEL_VALUE_LEFT_THUMBNAILS_MATERIALUI;
}
else
{
thumbnails_label_value = MENU_ENUM_LABEL_VALUE_THUMBNAILS;
left_thumbnails_label_value = MENU_ENUM_LABEL_VALUE_LEFT_THUMBNAILS;
}
CONFIG_UINT(
list, list_info,
&settings->uints.gfx_thumbnails,
MENU_ENUM_LABEL_THUMBNAILS,
thumbnails_label_value,
DEFAULT_GFX_THUMBNAILS_DEFAULT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_menu_thumbnails;
menu_settings_list_current_add_range(list, list_info, 0, 3, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_RADIO_BUTTONS;
CONFIG_UINT(
list, list_info,
&settings->uints.menu_left_thumbnails,
MENU_ENUM_LABEL_LEFT_THUMBNAILS,
left_thumbnails_label_value,
DEFAULT_MENU_LEFT_THUMBNAILS_DEFAULT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_menu_left_thumbnails;
menu_settings_list_current_add_range(list, list_info, 0, 3, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_RADIO_BUTTONS;
}
if (string_is_equal(settings->arrays.menu_driver, "xmb"))
{
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_xmb_vertical_thumbnails,
MENU_ENUM_LABEL_XMB_VERTICAL_THUMBNAILS,
MENU_ENUM_LABEL_VALUE_XMB_VERTICAL_THUMBNAILS,
DEFAULT_XMB_VERTICAL_THUMBNAILS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_UINT(
list, list_info,
&settings->uints.menu_xmb_thumbnail_scale_factor,
MENU_ENUM_LABEL_MENU_XMB_THUMBNAIL_SCALE_FACTOR,
MENU_ENUM_LABEL_VALUE_MENU_XMB_THUMBNAIL_SCALE_FACTOR,
DEFAULT_XMB_THUMBNAIL_SCALE_FACTOR,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].offset_by = 30;
menu_settings_list_current_add_range(list, list_info, (*list)[list_info->index - 1].offset_by, 100, 1, true, true);
}
if (string_is_equal(settings->arrays.menu_driver, "xmb") ||
string_is_equal(settings->arrays.menu_driver, "ozone") ||
string_is_equal(settings->arrays.menu_driver, "glui"))
{
CONFIG_UINT(
list, list_info,
&settings->uints.gfx_thumbnail_upscale_threshold,
MENU_ENUM_LABEL_MENU_THUMBNAIL_UPSCALE_THRESHOLD,
MENU_ENUM_LABEL_VALUE_MENU_THUMBNAIL_UPSCALE_THRESHOLD,
DEFAULT_GFX_THUMBNAIL_UPSCALE_THRESHOLD,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint_special;
menu_settings_list_current_add_range(list, list_info, 0, 1024, 256, true, true);
}
if (string_is_equal(settings->arrays.menu_driver, "rgui"))
{
CONFIG_UINT(
list, list_info,
&settings->uints.menu_rgui_thumbnail_downscaler,
MENU_ENUM_LABEL_MENU_RGUI_THUMBNAIL_DOWNSCALER,
MENU_ENUM_LABEL_VALUE_MENU_RGUI_THUMBNAIL_DOWNSCALER,
DEFAULT_RGUI_THUMBNAIL_DOWNSCALER,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_rgui_thumbnail_scaler;
menu_settings_list_current_add_range(list, list_info, 0, RGUI_THUMB_SCALE_LAST-1, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_RADIO_BUTTONS;
CONFIG_UINT(
list, list_info,
&settings->uints.menu_rgui_thumbnail_delay,
MENU_ENUM_LABEL_MENU_RGUI_THUMBNAIL_DELAY,
MENU_ENUM_LABEL_VALUE_MENU_RGUI_THUMBNAIL_DELAY,
DEFAULT_RGUI_THUMBNAIL_DELAY,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
menu_settings_list_current_add_range(list, list_info, 0.0f, 1024.0f, 64.0f, true, true);
}
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_timedate_enable,
MENU_ENUM_LABEL_TIMEDATE_ENABLE,
MENU_ENUM_LABEL_VALUE_TIMEDATE_ENABLE,
DEFAULT_MENU_TIMEDATE_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED);
CONFIG_UINT(list, list_info,
&settings->uints.menu_timedate_style,
MENU_ENUM_LABEL_TIMEDATE_STYLE,
MENU_ENUM_LABEL_VALUE_TIMEDATE_STYLE,
DEFAULT_MENU_TIMEDATE_STYLE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_menu_timedate_style;
menu_settings_list_current_add_range(list, list_info, 0, MENU_TIMEDATE_STYLE_LAST - 1, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
CONFIG_UINT(list, list_info,
&settings->uints.menu_timedate_date_separator,
MENU_ENUM_LABEL_TIMEDATE_DATE_SEPARATOR,
MENU_ENUM_LABEL_VALUE_TIMEDATE_DATE_SEPARATOR,
DEFAULT_MENU_TIMEDATE_DATE_SEPARATOR,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_menu_timedate_date_separator;
menu_settings_list_current_add_range(list, list_info, 0, MENU_TIMEDATE_DATE_SEPARATOR_LAST - 1, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_battery_level_enable,
MENU_ENUM_LABEL_BATTERY_LEVEL_ENABLE,
MENU_ENUM_LABEL_VALUE_BATTERY_LEVEL_ENABLE,
true,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED);
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_core_enable,
MENU_ENUM_LABEL_CORE_ENABLE,
MENU_ENUM_LABEL_VALUE_CORE_ENABLE,
true,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED);
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_show_sublabels,
MENU_ENUM_LABEL_MENU_SHOW_SUBLABELS,
MENU_ENUM_LABEL_VALUE_MENU_SHOW_SUBLABELS,
DEFAULT_MENU_SHOW_SUBLABELS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.use_last_start_directory,
MENU_ENUM_LABEL_USE_LAST_START_DIRECTORY,
MENU_ENUM_LABEL_VALUE_USE_LAST_START_DIRECTORY,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
case SETTINGS_LIST_MENU_FILE_BROWSER:
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_MENU_FILE_BROWSER_SETTINGS),
parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_MENU_FILE_BROWSER_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_navigation_browser_filter_supported_extensions_enable,
MENU_ENUM_LABEL_NAVIGATION_BROWSER_FILTER_SUPPORTED_EXTENSIONS_ENABLE,
MENU_ENUM_LABEL_VALUE_NAVIGATION_BROWSER_FILTER_SUPPORTED_EXTENSIONS_ENABLE,
true,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
case SETTINGS_LIST_MULTIMEDIA:
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_MULTIMEDIA_SETTINGS),
parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
CONFIG_BOOL(
list, list_info,
&settings->bools.multimedia_builtin_mediaplayer_enable,
MENU_ENUM_LABEL_USE_BUILTIN_PLAYER,
MENU_ENUM_LABEL_VALUE_USE_BUILTIN_PLAYER,
DEFAULT_BUILTIN_MEDIAPLAYER_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#ifdef HAVE_IMAGEVIEWER
CONFIG_BOOL(
list, list_info,
&settings->bools.multimedia_builtin_imageviewer_enable,
MENU_ENUM_LABEL_USE_BUILTIN_IMAGE_VIEWER,
MENU_ENUM_LABEL_VALUE_USE_BUILTIN_IMAGE_VIEWER,
DEFAULT_BUILTIN_IMAGEVIEWER_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#endif
CONFIG_BOOL(
list, list_info,
&settings->bools.filter_by_current_core,
MENU_ENUM_LABEL_FILTER_BY_CURRENT_CORE,
MENU_ENUM_LABEL_VALUE_FILTER_BY_CURRENT_CORE,
DEFAULT_FILTER_BY_CURRENT_CORE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
case SETTINGS_LIST_POWER_MANAGEMENT:
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_POWER_MANAGEMENT_SETTINGS),
parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_POWER_MANAGEMENT_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
#ifdef ANDROID
CONFIG_BOOL(
list, list_info,
&settings->bools.sustained_performance_mode,
MENU_ENUM_LABEL_SUSTAINED_PERFORMANCE_MODE,
MENU_ENUM_LABEL_VALUE_SUSTAINED_PERFORMANCE_MODE,
DEFAULT_SUSTAINED_PERFORMANCE_MODE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_CMD_APPLY_AUTO);
#endif
#ifdef HAVE_LAKKA
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_CPU_PERFPOWER,
MENU_ENUM_LABEL_VALUE_CPU_PERFPOWER,
&group_info,
&subgroup_info,
parent_group);
#endif
#ifndef HAVE_LAKKA
if (frontend_driver_has_gamemode())
CONFIG_BOOL(
list, list_info,
&settings->bools.gamemode_enable,
MENU_ENUM_LABEL_GAMEMODE_ENABLE,
MENU_ENUM_LABEL_VALUE_GAMEMODE_ENABLE,
DEFAULT_GAMEMODE_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.video_frame_rest,
MENU_ENUM_LABEL_VIDEO_FRAME_REST,
MENU_ENUM_LABEL_VALUE_VIDEO_FRAME_REST,
DEFAULT_FRAME_REST,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
#endif /*HAVE_LAKKA*/
case SETTINGS_LIST_WIFI_MANAGEMENT:
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_WIFI_SETTINGS),
parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_WIFI_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
CONFIG_BOOL(
list, list_info,
&settings->bools.wifi_enabled,
MENU_ENUM_LABEL_WIFI_ENABLED,
MENU_ENUM_LABEL_VALUE_WIFI_ENABLED,
DEFAULT_WIFI_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].action_ok = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_bool_action_right_with_refresh;
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_WIFI_NETWORK_SCAN,
MENU_ENUM_LABEL_VALUE_WIFI_NETWORK_SCAN,
&group_info,
&subgroup_info,
parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_WIFI_DISCONNECT,
MENU_ENUM_LABEL_VALUE_WIFI_DISCONNECT,
&group_info,
&subgroup_info,
parent_group);
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
case SETTINGS_LIST_ACCESSIBILITY:
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_ACCESSIBILITY_SETTINGS),
parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_ACCESSIBILITY_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
CONFIG_BOOL(
list, list_info,
&settings->bools.accessibility_enable,
MENU_ENUM_LABEL_ACCESSIBILITY_ENABLED,
MENU_ENUM_LABEL_VALUE_ACCESSIBILITY_ENABLED,
DEFAULT_ACCESSIBILITY_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].action_ok = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = setting_bool_action_right_with_refresh;
CONFIG_UINT(
list, list_info,
&settings->uints.accessibility_narrator_speech_speed,
MENU_ENUM_LABEL_ACCESSIBILITY_NARRATOR_SPEECH_SPEED,
MENU_ENUM_LABEL_VALUE_ACCESSIBILITY_NARRATOR_SPEECH_SPEED,
DEFAULT_ACCESSIBILITY_NARRATOR_SPEECH_SPEED,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
menu_settings_list_current_add_range(list, list_info, 1, 10, 1, true, true);
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
case SETTINGS_LIST_AI_SERVICE:
#ifdef HAVE_TRANSLATE
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_AI_SERVICE_SETTINGS),
parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_AI_SERVICE_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
CONFIG_UINT(
list, list_info,
&settings->uints.ai_service_mode,
MENU_ENUM_LABEL_AI_SERVICE_MODE,
MENU_ENUM_LABEL_VALUE_AI_SERVICE_MODE,
DEFAULT_AI_SERVICE_MODE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_ai_service_mode;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0, 2, 1, true, true);
CONFIG_STRING(
list, list_info,
settings->arrays.ai_service_url,
sizeof(settings->arrays.ai_service_url),
MENU_ENUM_LABEL_AI_SERVICE_URL,
MENU_ENUM_LABEL_VALUE_AI_SERVICE_URL,
DEFAULT_AI_SERVICE_URL,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_STRING_LINE_EDIT;
(*list)[list_info->index - 1].action_start = setting_generic_action_start_default;
CONFIG_BOOL(
list, list_info,
&settings->bools.ai_service_enable,
MENU_ENUM_LABEL_AI_SERVICE_ENABLE,
MENU_ENUM_LABEL_VALUE_AI_SERVICE_ENABLE,
DEFAULT_AI_SERVICE_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].action_ok = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = setting_bool_action_right_with_refresh;
CONFIG_BOOL(
list, list_info,
&settings->bools.ai_service_pause,
MENU_ENUM_LABEL_AI_SERVICE_PAUSE,
MENU_ENUM_LABEL_VALUE_AI_SERVICE_PAUSE,
DEFAULT_AI_SERVICE_PAUSE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_UINT(
list, list_info,
&settings->uints.ai_service_source_lang,
MENU_ENUM_LABEL_AI_SERVICE_SOURCE_LANG,
MENU_ENUM_LABEL_VALUE_AI_SERVICE_SOURCE_LANG,
DEFAULT_AI_SERVICE_SOURCE_LANG,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_ai_service_lang;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, TRANSLATION_LANG_DONT_CARE, (TRANSLATION_LANG_LAST-1), 1, true, true);
CONFIG_UINT(
list, list_info,
&settings->uints.ai_service_target_lang,
MENU_ENUM_LABEL_AI_SERVICE_TARGET_LANG,
MENU_ENUM_LABEL_VALUE_AI_SERVICE_TARGET_LANG,
DEFAULT_AI_SERVICE_TARGET_LANG,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_ai_service_lang;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, TRANSLATION_LANG_DONT_CARE, (TRANSLATION_LANG_LAST-1), 1, true, true);
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
#endif
break;
case SETTINGS_LIST_USER_INTERFACE:
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_USER_INTERFACE_SETTINGS),
parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_USER_INTERFACE_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
{
CONFIG_STRING_OPTIONS(
list, list_info,
settings->paths.app_icon,
sizeof(settings->paths.app_icon),
MENU_ENUM_LABEL_APPICON_SETTINGS,
MENU_ENUM_LABEL_VALUE_APPICON_SETTINGS,
"",
(char*)calloc(1, sizeof(char)),
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_IS_DRIVER);
(*list)[list_info->index - 1].action_ok = setting_action_ok_uint;
(*list)[list_info->index - 1].change_handler = appicon_change_handler;
}
CONFIG_BOOL(
list, list_info,
&settings->bools.pause_nonactive,
MENU_ENUM_LABEL_PAUSE_NONACTIVE,
MENU_ENUM_LABEL_VALUE_PAUSE_NONACTIVE,
DEFAULT_PAUSE_NONACTIVE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
#if !defined(RARCH_MOBILE)
CONFIG_BOOL(
list, list_info,
&settings->bools.video_disable_composition,
MENU_ENUM_LABEL_VIDEO_DISABLE_COMPOSITION,
MENU_ENUM_LABEL_VALUE_VIDEO_DISABLE_COMPOSITION,
DEFAULT_DISABLE_COMPOSITION,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_CMD_APPLY_AUTO);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_REINIT);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
#endif
#ifdef _3DS
{
u8 device_model = 0xFF;
/* Only O3DS and O3DSXL support running in 'dual-framebuffer'
* mode with the parallax barrier disabled
* (i.e. these are the only platforms that can use
* CTR_VIDEO_MODE_2D_400X240 and CTR_VIDEO_MODE_2D_800X240) */
CFGU_GetSystemModel(&device_model); /* (0 = O3DS, 1 = O3DSXL, 2 = N3DS, 3 = 2DS, 4 = N3DSXL, 5 = N2DSXL) */
CONFIG_UINT(
list, list_info,
&settings->uints.video_3ds_display_mode,
MENU_ENUM_LABEL_VIDEO_3DS_DISPLAY_MODE,
MENU_ENUM_LABEL_VALUE_VIDEO_3DS_DISPLAY_MODE,
DEFAULT_VIDEO_3DS_DISPLAY_MODE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_video_3ds_display_mode;
menu_settings_list_current_add_range(list, list_info, 0,
CTR_VIDEO_MODE_LAST - (((device_model == 0) || (device_model == 1)) ? 1 : 3),
1, true, true);
}
CONFIG_BOOL(
list, list_info,
&settings->bools.new3ds_speedup_enable,
MENU_ENUM_LABEL_NEW3DS_SPEEDUP_ENABLE,
MENU_ENUM_LABEL_VALUE_NEW3DS_SPEEDUP_ENABLE,
DEFAULT_NEW_3DS_SPEEDUP_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_CMD_APPLY_AUTO);
(*list)[list_info->index - 1].change_handler = new3ds_speedup_change_handler;
CONFIG_BOOL(
list, list_info,
&settings->bools.video_3ds_lcd_bottom,
MENU_ENUM_LABEL_VIDEO_3DS_LCD_BOTTOM,
MENU_ENUM_LABEL_VALUE_VIDEO_3DS_LCD_BOTTOM,
DEFAULT_VIDEO_3DS_LCD_BOTTOM,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_CMD_APPLY_AUTO);
(*list)[list_info->index - 1].action_ok = &setting_bool_action_left_with_refresh;
#ifdef CONSOLE_LOG
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_REINIT_FROM_TOGGLE);
#endif
CONFIG_DIR(
list, list_info,
settings->paths.directory_bottom_assets,
sizeof(settings->paths.directory_bottom_assets),
MENU_ENUM_LABEL_BOTTOM_ASSETS_DIRECTORY,
MENU_ENUM_LABEL_VALUE_BOTTOM_ASSETS_DIRECTORY,
g_defaults.dirs[DEFAULT_DIR_BOTTOM_ASSETS],
MENU_ENUM_LABEL_VALUE_DIRECTORY_DEFAULT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_REINIT);
CONFIG_BOOL(
list, list_info,
&settings->bools.bottom_font_enable,
MENU_ENUM_LABEL_BOTTOM_FONT_ENABLE,
MENU_ENUM_LABEL_VALUE_BOTTOM_FONT_ENABLE,
DEFAULT_BOTTOM_FONT_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_INT(
list, list_info,
&settings->ints.bottom_font_color_red,
MENU_ENUM_LABEL_BOTTOM_FONT_COLOR_RED,
MENU_ENUM_LABEL_VALUE_BOTTOM_FONT_COLOR_RED,
DEFAULT_BOTTOM_FONT_COLOR,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0, 255, 1, true, true);
CONFIG_INT(
list, list_info,
&settings->ints.bottom_font_color_green,
MENU_ENUM_LABEL_BOTTOM_FONT_COLOR_GREEN,
MENU_ENUM_LABEL_VALUE_BOTTOM_FONT_COLOR_GREEN,
DEFAULT_BOTTOM_FONT_COLOR,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0, 255, 1, true, true);
CONFIG_INT(
list, list_info,
&settings->ints.bottom_font_color_blue,
MENU_ENUM_LABEL_BOTTOM_FONT_COLOR_BLUE,
MENU_ENUM_LABEL_VALUE_BOTTOM_FONT_COLOR_BLUE,
DEFAULT_BOTTOM_FONT_COLOR,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0, 255, 1, true, true);
CONFIG_INT(
list, list_info,
&settings->ints.bottom_font_color_opacity,
MENU_ENUM_LABEL_BOTTOM_FONT_COLOR_OPACITY,
MENU_ENUM_LABEL_VALUE_BOTTOM_FONT_COLOR_OPACITY,
DEFAULT_BOTTOM_FONT_COLOR,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0, 255, 1, true, true);
CONFIG_FLOAT(
list, list_info,
&settings->floats.bottom_font_scale,
MENU_ENUM_LABEL_BOTTOM_FONT_SCALE,
MENU_ENUM_LABEL_VALUE_BOTTOM_FONT_SCALE,
DEFAULT_BOTTOM_FONT_SCALE,
"%.2f",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 1, 2, 0.01, true, true);
#endif
#ifdef HAVE_NETWORKING
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_show_online_updater,
MENU_ENUM_LABEL_MENU_SHOW_ONLINE_UPDATER,
MENU_ENUM_LABEL_VALUE_MENU_SHOW_ONLINE_UPDATER,
DEFAULT_MENU_SHOW_ONLINE_UPDATER,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#if !defined(HAVE_LAKKA)
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_show_core_updater,
MENU_ENUM_LABEL_MENU_SHOW_CORE_UPDATER,
MENU_ENUM_LABEL_VALUE_MENU_SHOW_CORE_UPDATER,
DEFAULT_MENU_SHOW_ONLINE_UPDATER,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#endif
#if 0
/* Thumbnailpack removal */
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_show_legacy_thumbnail_updater,
MENU_ENUM_LABEL_MENU_SHOW_LEGACY_THUMBNAIL_UPDATER,
MENU_ENUM_LABEL_VALUE_MENU_SHOW_LEGACY_THUMBNAIL_UPDATER,
DEFAULT_MENU_SHOW_LEGACY_THUMBNAIL_UPDATER,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#endif
#endif
#ifdef HAVE_MIST
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_show_core_manager_steam,
MENU_ENUM_LABEL_MENU_SHOW_CORE_MANAGER_STEAM,
MENU_ENUM_LABEL_VALUE_MENU_SHOW_CORE_MANAGER_STEAM,
DEFAULT_MENU_SHOW_CORE_MANAGER_STEAM,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#endif
CONFIG_BOOL(
list, list_info,
&settings->bools.settings_show_drivers,
MENU_ENUM_LABEL_SETTINGS_SHOW_DRIVERS,
MENU_ENUM_LABEL_VALUE_SETTINGS_SHOW_DRIVERS,
DEFAULT_SETTINGS_SHOW_DRIVERS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.settings_show_video,
MENU_ENUM_LABEL_SETTINGS_SHOW_VIDEO,
MENU_ENUM_LABEL_VALUE_SETTINGS_SHOW_VIDEO,
DEFAULT_SETTINGS_SHOW_VIDEO,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.settings_show_audio,
MENU_ENUM_LABEL_SETTINGS_SHOW_AUDIO,
MENU_ENUM_LABEL_VALUE_SETTINGS_SHOW_AUDIO,
DEFAULT_SETTINGS_SHOW_AUDIO,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.settings_show_input,
MENU_ENUM_LABEL_SETTINGS_SHOW_INPUT,
MENU_ENUM_LABEL_VALUE_SETTINGS_SHOW_INPUT,
DEFAULT_SETTINGS_SHOW_INPUT,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.settings_show_latency,
MENU_ENUM_LABEL_SETTINGS_SHOW_LATENCY,
MENU_ENUM_LABEL_VALUE_SETTINGS_SHOW_LATENCY,
DEFAULT_SETTINGS_SHOW_LATENCY,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.settings_show_core,
MENU_ENUM_LABEL_SETTINGS_SHOW_CORE,
MENU_ENUM_LABEL_VALUE_SETTINGS_SHOW_CORE,
DEFAULT_SETTINGS_SHOW_CORE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.settings_show_configuration,
MENU_ENUM_LABEL_SETTINGS_SHOW_CONFIGURATION,
MENU_ENUM_LABEL_VALUE_SETTINGS_SHOW_CONFIGURATION,
DEFAULT_SETTINGS_SHOW_CONFIGURATION,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.settings_show_saving,
MENU_ENUM_LABEL_SETTINGS_SHOW_SAVING,
MENU_ENUM_LABEL_VALUE_SETTINGS_SHOW_SAVING,
DEFAULT_SETTINGS_SHOW_SAVING,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.settings_show_logging,
MENU_ENUM_LABEL_SETTINGS_SHOW_LOGGING,
MENU_ENUM_LABEL_VALUE_SETTINGS_SHOW_LOGGING,
DEFAULT_SETTINGS_SHOW_LOGGING,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.settings_show_file_browser,
MENU_ENUM_LABEL_SETTINGS_SHOW_FILE_BROWSER,
MENU_ENUM_LABEL_VALUE_SETTINGS_SHOW_FILE_BROWSER,
DEFAULT_SETTINGS_SHOW_FILE_BROWSER,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.settings_show_frame_throttle,
MENU_ENUM_LABEL_SETTINGS_SHOW_FRAME_THROTTLE,
MENU_ENUM_LABEL_VALUE_SETTINGS_SHOW_FRAME_THROTTLE,
DEFAULT_SETTINGS_SHOW_FRAME_THROTTLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.settings_show_recording,
MENU_ENUM_LABEL_SETTINGS_SHOW_RECORDING,
MENU_ENUM_LABEL_VALUE_SETTINGS_SHOW_RECORDING,
DEFAULT_SETTINGS_SHOW_RECORDING,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.settings_show_onscreen_display,
MENU_ENUM_LABEL_SETTINGS_SHOW_ONSCREEN_DISPLAY,
MENU_ENUM_LABEL_VALUE_SETTINGS_SHOW_ONSCREEN_DISPLAY,
DEFAULT_SETTINGS_SHOW_ONSCREEN_DISPLAY,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.settings_show_user_interface,
MENU_ENUM_LABEL_SETTINGS_SHOW_USER_INTERFACE,
MENU_ENUM_LABEL_VALUE_SETTINGS_SHOW_USER_INTERFACE,
DEFAULT_SETTINGS_SHOW_USER_INTERFACE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.settings_show_ai_service,
MENU_ENUM_LABEL_SETTINGS_SHOW_AI_SERVICE,
MENU_ENUM_LABEL_VALUE_SETTINGS_SHOW_AI_SERVICE,
DEFAULT_SETTINGS_SHOW_AI_SERVICE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.settings_show_accessibility,
MENU_ENUM_LABEL_SETTINGS_SHOW_ACCESSIBILITY,
MENU_ENUM_LABEL_VALUE_SETTINGS_SHOW_ACCESSIBILITY,
DEFAULT_SETTINGS_SHOW_ACCESSIBILITY,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.settings_show_power_management,
MENU_ENUM_LABEL_SETTINGS_SHOW_POWER_MANAGEMENT,
MENU_ENUM_LABEL_VALUE_SETTINGS_SHOW_POWER_MANAGEMENT,
DEFAULT_SETTINGS_SHOW_POWER_MANAGEMENT,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.settings_show_achievements,
MENU_ENUM_LABEL_SETTINGS_SHOW_ACHIEVEMENTS,
MENU_ENUM_LABEL_VALUE_SETTINGS_SHOW_ACHIEVEMENTS,
DEFAULT_SETTINGS_SHOW_ACHIEVEMENTS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.settings_show_network,
MENU_ENUM_LABEL_SETTINGS_SHOW_NETWORK,
MENU_ENUM_LABEL_VALUE_SETTINGS_SHOW_NETWORK,
DEFAULT_SETTINGS_SHOW_NETWORK,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.settings_show_playlists,
MENU_ENUM_LABEL_SETTINGS_SHOW_PLAYLISTS,
MENU_ENUM_LABEL_VALUE_SETTINGS_SHOW_PLAYLISTS,
DEFAULT_SETTINGS_SHOW_PLAYLISTS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.settings_show_user,
MENU_ENUM_LABEL_SETTINGS_SHOW_USER,
MENU_ENUM_LABEL_VALUE_SETTINGS_SHOW_USER,
DEFAULT_SETTINGS_SHOW_USER,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.settings_show_directory,
MENU_ENUM_LABEL_SETTINGS_SHOW_DIRECTORY,
MENU_ENUM_LABEL_VALUE_SETTINGS_SHOW_DIRECTORY,
DEFAULT_SETTINGS_SHOW_DIRECTORY,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#ifdef HAVE_MIST
CONFIG_BOOL(
list, list_info,
&settings->bools.settings_show_steam,
MENU_ENUM_LABEL_SETTINGS_SHOW_STEAM,
MENU_ENUM_LABEL_VALUE_SETTINGS_SHOW_STEAM,
DEFAULT_SETTINGS_SHOW_STEAM,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#endif
CONFIG_BOOL(
list, list_info,
&settings->bools.quick_menu_show_take_screenshot,
MENU_ENUM_LABEL_QUICK_MENU_SHOW_TAKE_SCREENSHOT,
MENU_ENUM_LABEL_VALUE_QUICK_MENU_SHOW_TAKE_SCREENSHOT,
DEFAULT_QUICK_MENU_SHOW_TAKE_SCREENSHOT,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.quick_menu_show_savestate_submenu,
MENU_ENUM_LABEL_QUICK_MENU_SHOW_SAVESTATE_SUBMENU,
MENU_ENUM_LABEL_VALUE_QUICK_MENU_SHOW_SAVESTATE_SUBMENU,
DEFAULT_QUICK_MENU_SHOW_SAVESTATE_SUBMENU,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.quick_menu_show_save_load_state,
MENU_ENUM_LABEL_QUICK_MENU_SHOW_SAVE_LOAD_STATE,
MENU_ENUM_LABEL_VALUE_QUICK_MENU_SHOW_SAVE_LOAD_STATE,
DEFAULT_QUICK_MENU_SHOW_SAVE_LOAD_STATE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.quick_menu_show_replay,
MENU_ENUM_LABEL_QUICK_MENU_SHOW_REPLAY,
MENU_ENUM_LABEL_VALUE_QUICK_MENU_SHOW_REPLAY,
DEFAULT_QUICK_MENU_SHOW_REPLAY,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.quick_menu_show_undo_save_load_state,
MENU_ENUM_LABEL_QUICK_MENU_SHOW_UNDO_SAVE_LOAD_STATE,
MENU_ENUM_LABEL_VALUE_QUICK_MENU_SHOW_UNDO_SAVE_LOAD_STATE,
DEFAULT_QUICK_MENU_SHOW_UNDO_SAVE_LOAD_STATE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.quick_menu_show_add_to_favorites,
MENU_ENUM_LABEL_QUICK_MENU_SHOW_ADD_TO_FAVORITES,
MENU_ENUM_LABEL_VALUE_QUICK_MENU_SHOW_ADD_TO_FAVORITES,
DEFAULT_QUICK_MENU_SHOW_ADD_TO_FAVORITES,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.quick_menu_show_start_recording,
MENU_ENUM_LABEL_QUICK_MENU_SHOW_START_RECORDING,
MENU_ENUM_LABEL_VALUE_QUICK_MENU_SHOW_START_RECORDING,
DEFAULT_QUICK_MENU_SHOW_START_RECORDING,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.quick_menu_show_start_streaming,
MENU_ENUM_LABEL_QUICK_MENU_SHOW_START_STREAMING,
MENU_ENUM_LABEL_VALUE_QUICK_MENU_SHOW_START_STREAMING,
DEFAULT_QUICK_MENU_SHOW_START_STREAMING,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.quick_menu_show_set_core_association,
MENU_ENUM_LABEL_QUICK_MENU_SHOW_SET_CORE_ASSOCIATION,
MENU_ENUM_LABEL_VALUE_QUICK_MENU_SHOW_SET_CORE_ASSOCIATION,
DEFAULT_QUICK_MENU_SHOW_SET_CORE_ASSOCIATION,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.quick_menu_show_reset_core_association,
MENU_ENUM_LABEL_QUICK_MENU_SHOW_RESET_CORE_ASSOCIATION,
MENU_ENUM_LABEL_VALUE_QUICK_MENU_SHOW_RESET_CORE_ASSOCIATION,
DEFAULT_QUICK_MENU_SHOW_RESET_CORE_ASSOCIATION,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.quick_menu_show_resume_content,
MENU_ENUM_LABEL_QUICK_MENU_SHOW_RESUME_CONTENT,
MENU_ENUM_LABEL_VALUE_QUICK_MENU_SHOW_RESUME_CONTENT,
DEFAULT_QUICK_MENU_SHOW_RESUME_CONTENT,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.quick_menu_show_restart_content,
MENU_ENUM_LABEL_QUICK_MENU_SHOW_RESTART_CONTENT,
MENU_ENUM_LABEL_VALUE_QUICK_MENU_SHOW_RESTART_CONTENT,
DEFAULT_QUICK_MENU_SHOW_RESTART_CONTENT,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.quick_menu_show_close_content,
MENU_ENUM_LABEL_QUICK_MENU_SHOW_CLOSE_CONTENT,
MENU_ENUM_LABEL_VALUE_QUICK_MENU_SHOW_CLOSE_CONTENT,
DEFAULT_QUICK_MENU_SHOW_CLOSE_CONTENT,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.quick_menu_show_options,
MENU_ENUM_LABEL_QUICK_MENU_SHOW_OPTIONS,
MENU_ENUM_LABEL_VALUE_QUICK_MENU_SHOW_OPTIONS,
DEFAULT_QUICK_MENU_SHOW_CORE_OPTIONS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.quick_menu_show_core_options_flush,
MENU_ENUM_LABEL_QUICK_MENU_SHOW_CORE_OPTIONS_FLUSH,
MENU_ENUM_LABEL_VALUE_QUICK_MENU_SHOW_CORE_OPTIONS_FLUSH,
DEFAULT_QUICK_MENU_SHOW_CORE_OPTIONS_FLUSH,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.quick_menu_show_controls,
MENU_ENUM_LABEL_QUICK_MENU_SHOW_CONTROLS,
MENU_ENUM_LABEL_VALUE_QUICK_MENU_SHOW_CONTROLS,
DEFAULT_QUICK_MENU_SHOW_CONTROLS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.quick_menu_show_cheats,
MENU_ENUM_LABEL_QUICK_MENU_SHOW_CHEATS,
MENU_ENUM_LABEL_VALUE_QUICK_MENU_SHOW_CHEATS,
DEFAULT_QUICK_MENU_SHOW_CHEATS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
if (video_shader_any_supported())
{
CONFIG_BOOL(
list, list_info,
&settings->bools.quick_menu_show_shaders,
MENU_ENUM_LABEL_QUICK_MENU_SHOW_SHADERS,
MENU_ENUM_LABEL_VALUE_QUICK_MENU_SHOW_SHADERS,
DEFAULT_QUICK_MENU_SHOW_SHADERS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
}
#endif
CONFIG_BOOL(
list, list_info,
&settings->bools.quick_menu_show_save_core_overrides,
MENU_ENUM_LABEL_QUICK_MENU_SHOW_SAVE_CORE_OVERRIDES,
MENU_ENUM_LABEL_VALUE_QUICK_MENU_SHOW_SAVE_CORE_OVERRIDES,
DEFAULT_QUICK_MENU_SHOW_SAVE_CORE_OVERRIDES,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.quick_menu_show_save_content_dir_overrides,
MENU_ENUM_LABEL_QUICK_MENU_SHOW_SAVE_CONTENT_DIR_OVERRIDES,
MENU_ENUM_LABEL_VALUE_QUICK_MENU_SHOW_SAVE_CONTENT_DIR_OVERRIDES,
DEFAULT_QUICK_MENU_SHOW_SAVE_CONTENT_DIR_OVERRIDES,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.quick_menu_show_save_game_overrides,
MENU_ENUM_LABEL_QUICK_MENU_SHOW_SAVE_GAME_OVERRIDES,
MENU_ENUM_LABEL_VALUE_QUICK_MENU_SHOW_SAVE_GAME_OVERRIDES,
DEFAULT_QUICK_MENU_SHOW_SAVE_GAME_OVERRIDES,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.quick_menu_show_information,
MENU_ENUM_LABEL_QUICK_MENU_SHOW_INFORMATION,
MENU_ENUM_LABEL_VALUE_QUICK_MENU_SHOW_INFORMATION,
DEFAULT_QUICK_MENU_SHOW_INFORMATION,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#ifdef HAVE_NETWORKING
CONFIG_BOOL(
list, list_info,
&settings->bools.quick_menu_show_download_thumbnails,
MENU_ENUM_LABEL_QUICK_MENU_SHOW_DOWNLOAD_THUMBNAILS,
MENU_ENUM_LABEL_VALUE_QUICK_MENU_SHOW_DOWNLOAD_THUMBNAILS,
DEFAULT_QUICK_MENU_SHOW_DOWNLOAD_THUMBNAILS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#endif
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_scroll_fast,
MENU_ENUM_LABEL_MENU_SCROLL_FAST,
MENU_ENUM_LABEL_VALUE_MENU_SCROLL_FAST,
DEFAULT_MENU_SCROLL_FAST,
MENU_ENUM_LABEL_VALUE_SCROLL_NORMAL,
MENU_ENUM_LABEL_VALUE_SCROLL_FAST,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_UINT(
list, list_info,
&settings->uints.menu_scroll_delay,
MENU_ENUM_LABEL_MENU_SCROLL_DELAY,
MENU_ENUM_LABEL_VALUE_MENU_SCROLL_DELAY,
DEFAULT_MENU_SCROLL_DELAY,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].offset_by = 1;
menu_settings_list_current_add_range(list, list_info, 1, 999, 1, true, true);
#if defined(HAVE_QT) || defined(HAVE_COCOA)
CONFIG_BOOL(
list, list_info,
&settings->bools.ui_companion_enable,
MENU_ENUM_LABEL_UI_COMPANION_ENABLE,
MENU_ENUM_LABEL_VALUE_UI_COMPANION_ENABLE,
DEFAULT_UI_COMPANION_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED);
CONFIG_BOOL(
list, list_info,
&settings->bools.ui_companion_start_on_boot,
MENU_ENUM_LABEL_UI_COMPANION_START_ON_BOOT,
MENU_ENUM_LABEL_VALUE_UI_COMPANION_START_ON_BOOT,
DEFAULT_UI_COMPANION_START_ON_BOOT,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED);
CONFIG_BOOL(
list, list_info,
&settings->bools.desktop_menu_enable,
MENU_ENUM_LABEL_DESKTOP_MENU_ENABLE,
MENU_ENUM_LABEL_VALUE_DESKTOP_MENU_ENABLE,
DEFAULT_DESKTOP_MENU_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].action_ok = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = setting_bool_action_right_with_refresh;
CONFIG_BOOL(
list, list_info,
&settings->bools.ui_companion_toggle,
MENU_ENUM_LABEL_UI_COMPANION_TOGGLE,
MENU_ENUM_LABEL_VALUE_UI_COMPANION_TOGGLE,
DEFAULT_UI_COMPANION_TOGGLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#endif
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
case SETTINGS_LIST_PLAYLIST:
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_PLAYLIST_SETTINGS_BEGIN),
parent_group);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_SETTINGS);
START_SUB_GROUP(list, list_info, "History", &group_info, &subgroup_info, parent_group);
CONFIG_BOOL(
list, list_info,
&settings->bools.history_list_enable,
MENU_ENUM_LABEL_HISTORY_LIST_ENABLE,
MENU_ENUM_LABEL_VALUE_HISTORY_LIST_ENABLE,
DEFAULT_HISTORY_LIST_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED
);
(*list)[list_info->index - 1].action_ok = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = setting_bool_action_right_with_refresh;
CONFIG_UINT(
list, list_info,
&settings->uints.content_history_size,
MENU_ENUM_LABEL_CONTENT_HISTORY_SIZE,
MENU_ENUM_LABEL_VALUE_CONTENT_HISTORY_SIZE,
DEFAULT_CONTENT_HISTORY_SIZE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].offset_by = 1;
menu_settings_list_current_add_range(list, list_info, 1.0f, 9999.0f, 1.0f, true, true);
END_SUB_GROUP(list, list_info, parent_group);
START_SUB_GROUP(list, list_info, "Playlist", &group_info, &subgroup_info, parent_group);
/* Favourites size is traditionally associtated with
* history size, but they are in fact unrelated. We
* therefore place this entry outside the "History"
* sub group. */
CONFIG_INT(
list, list_info,
&settings->ints.content_favorites_size,
MENU_ENUM_LABEL_CONTENT_FAVORITES_SIZE,
MENU_ENUM_LABEL_VALUE_CONTENT_FAVORITES_SIZE,
DEFAULT_CONTENT_FAVORITES_SIZE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].offset_by = -1;
menu_settings_list_current_add_range(list, list_info, -1.0f, 9999.0f, 1.0f, true, true);
CONFIG_BOOL(
list, list_info,
&settings->bools.playlist_entry_rename,
MENU_ENUM_LABEL_PLAYLIST_ENTRY_RENAME,
MENU_ENUM_LABEL_VALUE_PLAYLIST_ENTRY_RENAME,
DEFAULT_PLAYLIST_ENTRY_RENAME,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_UINT(
list, list_info,
&settings->uints.playlist_entry_remove_enable,
MENU_ENUM_LABEL_PLAYLIST_ENTRY_REMOVE,
MENU_ENUM_LABEL_VALUE_PLAYLIST_ENTRY_REMOVE,
DEFAULT_PLAYLIST_ENTRY_REMOVE_ENABLE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_playlist_entry_remove_enable;
menu_settings_list_current_add_range(list, list_info, 0, PLAYLIST_ENTRY_REMOVE_ENABLE_LAST-1, 1, true, true);
CONFIG_BOOL(
list, list_info,
&settings->bools.playlist_sort_alphabetical,
MENU_ENUM_LABEL_PLAYLIST_SORT_ALPHABETICAL,
MENU_ENUM_LABEL_VALUE_PLAYLIST_SORT_ALPHABETICAL,
DEFAULT_PLAYLIST_SORT_ALPHABETICAL,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.playlist_use_old_format,
MENU_ENUM_LABEL_PLAYLIST_USE_OLD_FORMAT,
MENU_ENUM_LABEL_VALUE_PLAYLIST_USE_OLD_FORMAT,
DEFAULT_PLAYLIST_USE_OLD_FORMAT,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
#if defined(HAVE_ZLIB)
CONFIG_BOOL(
list, list_info,
&settings->bools.playlist_compression,
MENU_ENUM_LABEL_PLAYLIST_COMPRESSION,
MENU_ENUM_LABEL_VALUE_PLAYLIST_COMPRESSION,
DEFAULT_PLAYLIST_COMPRESSION,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
#endif
CONFIG_BOOL(
list, list_info,
&settings->bools.playlist_show_sublabels,
MENU_ENUM_LABEL_PLAYLIST_SHOW_SUBLABELS,
MENU_ENUM_LABEL_VALUE_PLAYLIST_SHOW_SUBLABELS,
DEFAULT_PLAYLIST_SHOW_SUBLABELS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
(*list)[list_info->index - 1].action_ok = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = setting_bool_action_right_with_refresh;
/* Playlist entry index display and content specific history icon
* are currently supported only by Ozone & XMB */
if (string_is_equal(settings->arrays.menu_driver, "xmb") ||
string_is_equal(settings->arrays.menu_driver, "ozone"))
{
CONFIG_UINT(
list, list_info,
&settings->uints.playlist_show_history_icons,
MENU_ENUM_LABEL_PLAYLIST_SHOW_HISTORY_ICONS,
MENU_ENUM_LABEL_VALUE_PLAYLIST_SHOW_HISTORY_ICONS,
DEFAULT_PLAYLIST_SHOW_HISTORY_ICONS,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_playlist_show_history_icons;
menu_settings_list_current_add_range(list, list_info, 0, PLAYLIST_SHOW_HISTORY_ICONS_LAST-1, 1, true, true);
CONFIG_BOOL(
list, list_info,
&settings->bools.playlist_show_entry_idx,
MENU_ENUM_LABEL_PLAYLIST_SHOW_ENTRY_IDX,
MENU_ENUM_LABEL_VALUE_PLAYLIST_SHOW_ENTRY_IDX,
DEFAULT_PLAYLIST_SHOW_ENTRY_IDX,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
}
CONFIG_UINT(
list, list_info,
&settings->uints.playlist_sublabel_runtime_type,
MENU_ENUM_LABEL_PLAYLIST_SUBLABEL_RUNTIME_TYPE,
MENU_ENUM_LABEL_VALUE_PLAYLIST_SUBLABEL_RUNTIME_TYPE,
DEFAULT_PLAYLIST_SUBLABEL_RUNTIME_TYPE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_playlist_sublabel_runtime_type;
menu_settings_list_current_add_range(list, list_info, 0, PLAYLIST_RUNTIME_LAST-1, 1, true, true);
CONFIG_UINT(
list, list_info,
&settings->uints.playlist_sublabel_last_played_style,
MENU_ENUM_LABEL_PLAYLIST_SUBLABEL_LAST_PLAYED_STYLE,
MENU_ENUM_LABEL_VALUE_PLAYLIST_SUBLABEL_LAST_PLAYED_STYLE,
DEFAULT_PLAYLIST_SUBLABEL_LAST_PLAYED_STYLE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_playlist_sublabel_last_played_style;
menu_settings_list_current_add_range(list, list_info, 0, PLAYLIST_LAST_PLAYED_STYLE_LAST-1, 1, true, true);
CONFIG_UINT(
list, list_info,
&settings->uints.playlist_show_inline_core_name,
MENU_ENUM_LABEL_PLAYLIST_SHOW_INLINE_CORE_NAME,
MENU_ENUM_LABEL_VALUE_PLAYLIST_SHOW_INLINE_CORE_NAME,
DEFAULT_PLAYLIST_SHOW_INLINE_CORE_NAME,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_playlist_inline_core_display_type;
menu_settings_list_current_add_range(list, list_info, 0, PLAYLIST_INLINE_CORE_DISPLAY_LAST-1, 1, true, true);
CONFIG_BOOL(
list, list_info,
&settings->bools.playlist_fuzzy_archive_match,
MENU_ENUM_LABEL_PLAYLIST_FUZZY_ARCHIVE_MATCH,
MENU_ENUM_LABEL_VALUE_PLAYLIST_FUZZY_ARCHIVE_MATCH,
DEFAULT_PLAYLIST_FUZZY_ARCHIVE_MATCH,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.playlist_portable_paths,
MENU_ENUM_LABEL_PLAYLIST_PORTABLE_PATHS,
MENU_ENUM_LABEL_VALUE_PLAYLIST_PORTABLE_PATHS,
DEFAULT_PLAYLIST_PORTABLE_PATHS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.playlist_use_filename,
MENU_ENUM_LABEL_PLAYLIST_USE_FILENAME,
MENU_ENUM_LABEL_VALUE_PLAYLIST_USE_FILENAME,
DEFAULT_PLAYLIST_USE_FILENAME,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
#if defined(HAVE_OZONE) || defined(HAVE_XMB)
if (string_is_equal(settings->arrays.menu_driver, "ozone") ||
string_is_equal(settings->arrays.menu_driver, "xmb"))
{
CONFIG_BOOL(
list, list_info,
&settings->bools.ozone_truncate_playlist_name,
MENU_ENUM_LABEL_OZONE_TRUNCATE_PLAYLIST_NAME,
MENU_ENUM_LABEL_VALUE_OZONE_TRUNCATE_PLAYLIST_NAME,
DEFAULT_OZONE_TRUNCATE_PLAYLIST_NAME,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].action_ok = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = setting_bool_action_right_with_refresh;
CONFIG_BOOL(
list, list_info,
&settings->bools.ozone_sort_after_truncate_playlist_name,
MENU_ENUM_LABEL_OZONE_SORT_AFTER_TRUNCATE_PLAYLIST_NAME,
MENU_ENUM_LABEL_VALUE_OZONE_SORT_AFTER_TRUNCATE_PLAYLIST_NAME,
DEFAULT_OZONE_SORT_AFTER_TRUNCATE_PLAYLIST_NAME,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
}
#endif
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
case SETTINGS_LIST_CHEEVOS:
#ifdef HAVE_CHEEVOS
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_CHEEVOS_SETTINGS),
parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_RETRO_ACHIEVEMENTS_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
CONFIG_BOOL(
list, list_info,
&settings->bools.cheevos_enable,
MENU_ENUM_LABEL_CHEEVOS_ENABLE,
MENU_ENUM_LABEL_VALUE_CHEEVOS_ENABLE,
DEFAULT_CHEEVOS_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
achievement_hardcore_mode_write_handler, /* re-evaluate whether hardcore is enabled */
general_read_handler,
SD_FLAG_NONE
);
(*list)[list_info->index - 1].action_ok = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = setting_bool_action_right_with_refresh;
CONFIG_BOOL(
list, list_info,
&settings->bools.cheevos_test_unofficial,
MENU_ENUM_LABEL_CHEEVOS_TEST_UNOFFICIAL,
MENU_ENUM_LABEL_VALUE_CHEEVOS_TEST_UNOFFICIAL,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED
);
CONFIG_BOOL(
list, list_info,
&settings->bools.cheevos_richpresence_enable,
MENU_ENUM_LABEL_CHEEVOS_RICHPRESENCE_ENABLE,
MENU_ENUM_LABEL_VALUE_CHEEVOS_RICHPRESENCE_ENABLE,
true,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED
);
#ifndef HAVE_GFX_WIDGETS
if (string_is_equal(settings->arrays.menu_driver, "xmb") || string_is_equal(settings->arrays.menu_driver, "ozone"))
CONFIG_BOOL(
list, list_info,
&settings->bools.cheevos_badges_enable,
MENU_ENUM_LABEL_CHEEVOS_BADGES_ENABLE,
MENU_ENUM_LABEL_VALUE_CHEEVOS_BADGES_ENABLE,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED
);
#endif
#ifdef HAVE_AUDIOMIXER
CONFIG_BOOL(
list, list_info,
&settings->bools.cheevos_unlock_sound_enable,
MENU_ENUM_LABEL_CHEEVOS_UNLOCK_SOUND_ENABLE,
MENU_ENUM_LABEL_VALUE_CHEEVOS_UNLOCK_SOUND_ENABLE,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
#endif
CONFIG_BOOL(
list, list_info,
&settings->bools.cheevos_auto_screenshot,
MENU_ENUM_LABEL_CHEEVOS_AUTO_SCREENSHOT,
MENU_ENUM_LABEL_VALUE_CHEEVOS_AUTO_SCREENSHOT,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.cheevos_start_active,
MENU_ENUM_LABEL_CHEEVOS_START_ACTIVE,
MENU_ENUM_LABEL_VALUE_CHEEVOS_START_ACTIVE,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED
);
CONFIG_BOOL(
list, list_info,
&settings->bools.cheevos_hardcore_mode_enable,
MENU_ENUM_LABEL_CHEEVOS_HARDCORE_MODE_ENABLE,
MENU_ENUM_LABEL_VALUE_CHEEVOS_HARDCORE_MODE_ENABLE,
true,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
achievement_hardcore_mode_write_handler,
general_read_handler,
SD_FLAG_NONE
);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_CHEEVOS_HARDCORE_MODE_TOGGLE);
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
#endif
break;
case SETTINGS_LIST_CHEEVOS_APPEARANCE:
#ifdef HAVE_CHEEVOS
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_CHEEVOS_APPEARANCE_SETTINGS),
parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_CHEEVOS_APPEARANCE_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
#ifdef HAVE_GFX_WIDGETS
CONFIG_UINT(
list, list_info,
&settings->uints.cheevos_appearance_anchor,
MENU_ENUM_LABEL_CHEEVOS_APPEARANCE_ANCHOR,
MENU_ENUM_LABEL_VALUE_CHEEVOS_APPEARANCE_ANCHOR,
DEFAULT_CHEEVOS_APPEARANCE_ANCHOR,
&group_info,
&subgroup_info,
parent_group,
cheevos_appearance_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].action_left = &setting_uint_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_uint_action_right_with_refresh;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_cheevos_appearance_anchor;
menu_settings_list_current_add_range(list, list_info, 0, CHEEVOS_APPEARANCE_ANCHOR_LAST - 1, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
CONFIG_BOOL(
list, list_info,
&settings->bools.cheevos_appearance_padding_auto,
MENU_ENUM_LABEL_CHEEVOS_APPEARANCE_PADDING_AUTO,
MENU_ENUM_LABEL_VALUE_CHEEVOS_APPEARANCE_PADDING_AUTO,
true,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
cheevos_appearance_write_handler,
general_read_handler,
SD_FLAG_NONE
);
(*list)[list_info->index - 1].action_ok = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = setting_bool_action_right_with_refresh;
CONFIG_FLOAT(
list, list_info,
&settings->floats.cheevos_appearance_padding_h,
MENU_ENUM_LABEL_CHEEVOS_APPEARANCE_PADDING_H,
MENU_ENUM_LABEL_VALUE_CHEEVOS_APPEARANCE_PADDING_H,
DEFAULT_CHEEVOS_APPEARANCE_PADDING_H,
"%.2f",
&group_info,
&subgroup_info,
parent_group,
cheevos_appearance_write_handler,
general_read_handler
);
menu_settings_list_current_add_range(list, list_info, 0.0, 0.5, 0.01, true, true);
CONFIG_FLOAT(
list, list_info,
&settings->floats.cheevos_appearance_padding_v,
MENU_ENUM_LABEL_CHEEVOS_APPEARANCE_PADDING_V,
MENU_ENUM_LABEL_VALUE_CHEEVOS_APPEARANCE_PADDING_V,
DEFAULT_CHEEVOS_APPEARANCE_PADDING_V,
"%.2f",
&group_info,
&subgroup_info,
parent_group,
cheevos_appearance_write_handler,
general_read_handler
);
menu_settings_list_current_add_range(list, list_info, 0.0, 0.5, 0.01, true, true);
#endif
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
#endif
break;
case SETTINGS_LIST_CHEEVOS_VISIBILITY:
#ifdef HAVE_CHEEVOS
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_CHEEVOS_VISIBILITY_SETTINGS),
parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_CHEEVOS_VISIBILITY_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
CONFIG_UINT(
list, list_info,
&settings->uints.cheevos_visibility_summary,
MENU_ENUM_LABEL_CHEEVOS_VISIBILITY_SUMMARY,
MENU_ENUM_LABEL_VALUE_CHEEVOS_VISIBILITY_SUMMARY,
DEFAULT_CHEEVOS_VISIBILITY_SUMMARY,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].action_left = &setting_uint_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_uint_action_right_with_refresh;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_cheevos_visibility_summary;
menu_settings_list_current_add_range(list, list_info, 0, RCHEEVOS_SUMMARY_LAST - 1, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
CONFIG_BOOL(
list, list_info,
&settings->bools.cheevos_visibility_unlock,
MENU_ENUM_LABEL_CHEEVOS_VISIBILITY_UNLOCK,
MENU_ENUM_LABEL_VALUE_CHEEVOS_VISIBILITY_UNLOCK,
DEFAULT_CHEEVOS_VISIBILITY_UNLOCK,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.cheevos_visibility_mastery,
MENU_ENUM_LABEL_CHEEVOS_VISIBILITY_MASTERY,
MENU_ENUM_LABEL_VALUE_CHEEVOS_VISIBILITY_MASTERY,
DEFAULT_CHEEVOS_VISIBILITY_MASTERY,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.cheevos_challenge_indicators,
MENU_ENUM_LABEL_CHEEVOS_CHALLENGE_INDICATORS,
MENU_ENUM_LABEL_VALUE_CHEEVOS_CHALLENGE_INDICATORS,
true,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.cheevos_visibility_progress_tracker,
MENU_ENUM_LABEL_CHEEVOS_VISIBILITY_PROGRESS_TRACKER,
MENU_ENUM_LABEL_VALUE_CHEEVOS_VISIBILITY_PROGRESS_TRACKER,
DEFAULT_CHEEVOS_VISIBILITY_PROGRESS_TRACKER,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.cheevos_visibility_lboard_start,
MENU_ENUM_LABEL_CHEEVOS_VISIBILITY_LBOARD_START,
MENU_ENUM_LABEL_VALUE_CHEEVOS_VISIBILITY_LBOARD_START,
DEFAULT_CHEEVOS_VISIBILITY_LBOARD_START,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.cheevos_visibility_lboard_submit,
MENU_ENUM_LABEL_CHEEVOS_VISIBILITY_LBOARD_SUBMIT,
MENU_ENUM_LABEL_VALUE_CHEEVOS_VISIBILITY_LBOARD_SUBMIT,
DEFAULT_CHEEVOS_VISIBILITY_LBOARD_SUBMIT,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.cheevos_visibility_lboard_cancel,
MENU_ENUM_LABEL_CHEEVOS_VISIBILITY_LBOARD_CANCEL,
MENU_ENUM_LABEL_VALUE_CHEEVOS_VISIBILITY_LBOARD_CANCEL,
DEFAULT_CHEEVOS_VISIBILITY_LBOARD_CANCEL,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.cheevos_visibility_lboard_trackers,
MENU_ENUM_LABEL_CHEEVOS_VISIBILITY_LBOARD_TRACKERS,
MENU_ENUM_LABEL_VALUE_CHEEVOS_VISIBILITY_LBOARD_TRACKERS,
DEFAULT_CHEEVOS_VISIBILITY_LBOARD_TRACKERS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
achievement_leaderboard_trackers_enabled_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.cheevos_verbose_enable,
MENU_ENUM_LABEL_CHEEVOS_VERBOSE_ENABLE,
MENU_ENUM_LABEL_VALUE_CHEEVOS_VERBOSE_ENABLE,
true,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED
);
CONFIG_BOOL(
list, list_info,
&settings->bools.cheevos_visibility_account,
MENU_ENUM_LABEL_CHEEVOS_VISIBILITY_ACCOUNT,
MENU_ENUM_LABEL_VALUE_CHEEVOS_VISIBILITY_ACCOUNT,
DEFAULT_CHEEVOS_VISIBILITY_ACCOUNT,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED
);
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
#endif
break;
case SETTINGS_LIST_CORE_UPDATER:
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_CORE_UPDATER_SETTINGS),
parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_UPDATER_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
#ifdef HAVE_NETWORKING
#ifdef HAVE_UPDATE_CORES
#if defined(ANDROID)
/* Play Store builds do not fetch cores
* from the buildbot */
if (!play_feature_delivery_enabled())
#endif
{
CONFIG_STRING(
list, list_info,
settings->paths.network_buildbot_url,
sizeof(settings->paths.network_buildbot_url),
MENU_ENUM_LABEL_CORE_UPDATER_BUILDBOT_URL,
MENU_ENUM_LABEL_VALUE_CORE_UPDATER_BUILDBOT_URL,
DEFAULT_BUILDBOT_SERVER_URL,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_STRING_LINE_EDIT;
(*list)[list_info->index - 1].action_start = setting_generic_action_start_default;
}
#endif
CONFIG_STRING(
list, list_info,
settings->paths.network_buildbot_assets_url,
sizeof(settings->paths.network_buildbot_assets_url),
MENU_ENUM_LABEL_BUILDBOT_ASSETS_URL,
MENU_ENUM_LABEL_VALUE_BUILDBOT_ASSETS_URL,
DEFAULT_BUILDBOT_ASSETS_SERVER_URL,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_STRING_LINE_EDIT;
(*list)[list_info->index - 1].action_start = setting_generic_action_start_default;
CONFIG_BOOL(
list, list_info,
&settings->bools.network_buildbot_auto_extract_archive,
MENU_ENUM_LABEL_CORE_UPDATER_AUTO_EXTRACT_ARCHIVE,
MENU_ENUM_LABEL_VALUE_CORE_UPDATER_AUTO_EXTRACT_ARCHIVE,
DEFAULT_NETWORK_BUILDBOT_AUTO_EXTRACT_ARCHIVE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_BOOL(
list, list_info,
&settings->bools.network_buildbot_show_experimental_cores,
MENU_ENUM_LABEL_CORE_UPDATER_SHOW_EXPERIMENTAL_CORES,
MENU_ENUM_LABEL_VALUE_CORE_UPDATER_SHOW_EXPERIMENTAL_CORES,
DEFAULT_NETWORK_BUILDBOT_SHOW_EXPERIMENTAL_CORES,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
#if defined(ANDROID)
/* Play Store builds do not support automatic
* core backups */
if (!play_feature_delivery_enabled())
#endif
{
CONFIG_BOOL(
list, list_info,
&settings->bools.core_updater_auto_backup,
MENU_ENUM_LABEL_CORE_UPDATER_AUTO_BACKUP,
MENU_ENUM_LABEL_VALUE_CORE_UPDATER_AUTO_BACKUP,
DEFAULT_CORE_UPDATER_AUTO_BACKUP,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_UINT(
list, list_info,
&settings->uints.core_updater_auto_backup_history_size,
MENU_ENUM_LABEL_CORE_UPDATER_AUTO_BACKUP_HISTORY_SIZE,
MENU_ENUM_LABEL_VALUE_CORE_UPDATER_AUTO_BACKUP_HISTORY_SIZE,
DEFAULT_CORE_UPDATER_AUTO_BACKUP_HISTORY_SIZE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].offset_by = 1;
menu_settings_list_current_add_range(list, list_info, (*list)[list_info->index - 1].offset_by, 500, 1, true, true);
}
#endif
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
case SETTINGS_LIST_NETPLAY:
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NETWORK_SETTINGS),
parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_NETWORK_SETTINGS);
START_SUB_GROUP(list, list_info, "Netplay", &group_info, &subgroup_info, parent_group);
{
#if defined(HAVE_NETWORKING)
unsigned user;
char dev_req_label[64];
char dev_req_value[64];
CONFIG_BOOL(
list, list_info,
&settings->bools.netplay_show_only_connectable,
MENU_ENUM_LABEL_NETPLAY_SHOW_ONLY_CONNECTABLE,
MENU_ENUM_LABEL_VALUE_NETPLAY_SHOW_ONLY_CONNECTABLE,
DEFAULT_NETPLAY_SHOW_ONLY_CONNECTABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.netplay_show_only_installed_cores,
MENU_ENUM_LABEL_NETPLAY_SHOW_ONLY_INSTALLED_CORES,
MENU_ENUM_LABEL_VALUE_NETPLAY_SHOW_ONLY_INSTALLED_CORES,
DEFAULT_NETPLAY_SHOW_ONLY_INSTALLED_CORES,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.netplay_show_passworded,
MENU_ENUM_LABEL_NETPLAY_SHOW_PASSWORDED,
MENU_ENUM_LABEL_VALUE_NETPLAY_SHOW_PASSWORDED,
DEFAULT_NETPLAY_SHOW_PASSWORDED,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.netplay_public_announce,
MENU_ENUM_LABEL_NETPLAY_PUBLIC_ANNOUNCE,
MENU_ENUM_LABEL_VALUE_NETPLAY_PUBLIC_ANNOUNCE,
DEFAULT_NETPLAY_PUBLIC_ANNOUNCE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.netplay_use_mitm_server,
MENU_ENUM_LABEL_NETPLAY_USE_MITM_SERVER,
MENU_ENUM_LABEL_VALUE_NETPLAY_USE_MITM_SERVER,
DEFAULT_NETPLAY_USE_MITM_SERVER,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].action_ok = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_bool_action_right_with_refresh;
CONFIG_STRING(
list, list_info,
settings->arrays.netplay_mitm_server,
sizeof(settings->arrays.netplay_mitm_server),
MENU_ENUM_LABEL_NETPLAY_MITM_SERVER,
MENU_ENUM_LABEL_VALUE_NETPLAY_MITM_SERVER,
DEFAULT_NETPLAY_MITM_SERVER,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = setting_generic_action_start_default;
(*list)[list_info->index - 1].action_ok = setting_string_action_ok_netplay_mitm_server;
(*list)[list_info->index - 1].action_left = setting_string_action_left_netplay_mitm_server;
(*list)[list_info->index - 1].action_right = setting_string_action_right_netplay_mitm_server;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_netplay_mitm_server;
CONFIG_STRING(
list, list_info,
settings->paths.netplay_custom_mitm_server,
sizeof(settings->paths.netplay_custom_mitm_server),
MENU_ENUM_LABEL_NETPLAY_CUSTOM_MITM_SERVER,
MENU_ENUM_LABEL_VALUE_NETPLAY_CUSTOM_MITM_SERVER,
"",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_STRING_LINE_EDIT;
(*list)[list_info->index - 1].action_start = setting_generic_action_start_default;
CONFIG_STRING(
list, list_info,
settings->paths.netplay_server,
sizeof(settings->paths.netplay_server),
MENU_ENUM_LABEL_NETPLAY_IP_ADDRESS,
MENU_ENUM_LABEL_VALUE_NETPLAY_IP_ADDRESS,
"",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_STRING_LINE_EDIT;
(*list)[list_info->index - 1].action_start = setting_generic_action_start_default;
CONFIG_UINT(
list, list_info,
&settings->uints.netplay_port,
MENU_ENUM_LABEL_NETPLAY_TCP_UDP_PORT,
MENU_ENUM_LABEL_VALUE_NETPLAY_TCP_UDP_PORT,
RARCH_DEFAULT_PORT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0, 65535, 1, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
CONFIG_UINT(
list, list_info,
&settings->uints.netplay_max_connections,
MENU_ENUM_LABEL_NETPLAY_MAX_CONNECTIONS,
MENU_ENUM_LABEL_VALUE_NETPLAY_MAX_CONNECTIONS,
DEFAULT_NETPLAY_MAX_CONNECTIONS,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_SPINBOX;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].offset_by = 1;
menu_settings_list_current_add_range(list, list_info, 1, 31, 1, true, true);
CONFIG_UINT(
list, list_info,
&settings->uints.netplay_max_ping,
MENU_ENUM_LABEL_NETPLAY_MAX_PING,
MENU_ENUM_LABEL_VALUE_NETPLAY_MAX_PING,
DEFAULT_NETPLAY_MAX_PING,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_SPINBOX;
menu_settings_list_current_add_range(list, list_info, 0, 500, 10, true, true);
CONFIG_STRING(
list, list_info,
settings->paths.netplay_password,
sizeof(settings->paths.netplay_password),
MENU_ENUM_LABEL_NETPLAY_PASSWORD,
MENU_ENUM_LABEL_VALUE_NETPLAY_PASSWORD,
"",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_PASSWORD_LINE_EDIT;
(*list)[list_info->index - 1].action_start = setting_generic_action_start_default;
CONFIG_STRING(
list, list_info,
settings->paths.netplay_spectate_password,
sizeof(settings->paths.netplay_spectate_password),
MENU_ENUM_LABEL_NETPLAY_SPECTATE_PASSWORD,
MENU_ENUM_LABEL_VALUE_NETPLAY_SPECTATE_PASSWORD,
"",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_PASSWORD_LINE_EDIT;
(*list)[list_info->index - 1].action_start = setting_generic_action_start_default;
CONFIG_BOOL(
list, list_info,
&settings->bools.netplay_start_as_spectator,
MENU_ENUM_LABEL_NETPLAY_START_AS_SPECTATOR,
MENU_ENUM_LABEL_VALUE_NETPLAY_START_AS_SPECTATOR,
DEFAULT_NETPLAY_START_AS_SPECTATOR,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.netplay_fade_chat,
MENU_ENUM_LABEL_NETPLAY_FADE_CHAT,
MENU_ENUM_LABEL_VALUE_NETPLAY_FADE_CHAT,
DEFAULT_NETPLAY_FADE_CHAT,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_UINT(
list, list_info,
&settings->uints.netplay_chat_color_name,
MENU_ENUM_LABEL_NETPLAY_CHAT_COLOR_NAME,
MENU_ENUM_LABEL_VALUE_NETPLAY_CHAT_COLOR_NAME,
DEFAULT_NETPLAY_CHAT_COLOR_NAME,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_color_rgb;
(*list)[list_info->index - 1].action_select = &setting_action_ok_color_rgb;
(*list)[list_info->index - 1].action_left = NULL;
(*list)[list_info->index - 1].action_right = NULL;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_color_rgb;
CONFIG_UINT(
list, list_info,
&settings->uints.netplay_chat_color_msg,
MENU_ENUM_LABEL_NETPLAY_CHAT_COLOR_MSG,
MENU_ENUM_LABEL_VALUE_NETPLAY_CHAT_COLOR_MSG,
DEFAULT_NETPLAY_CHAT_COLOR_MSG,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_color_rgb;
(*list)[list_info->index - 1].action_select = &setting_action_ok_color_rgb;
(*list)[list_info->index - 1].action_left = NULL;
(*list)[list_info->index - 1].action_right = NULL;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_color_rgb;
CONFIG_BOOL(
list, list_info,
&settings->bools.netplay_allow_pausing,
MENU_ENUM_LABEL_NETPLAY_ALLOW_PAUSING,
MENU_ENUM_LABEL_VALUE_NETPLAY_ALLOW_PAUSING,
DEFAULT_NETPLAY_ALLOW_PAUSING,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
&settings->bools.netplay_allow_slaves,
MENU_ENUM_LABEL_NETPLAY_ALLOW_SLAVES,
MENU_ENUM_LABEL_VALUE_NETPLAY_ALLOW_SLAVES,
DEFAULT_NETPLAY_ALLOW_SLAVES,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
(*list)[list_info->index - 1].action_ok = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_bool_action_right_with_refresh;
CONFIG_BOOL(
list, list_info,
&settings->bools.netplay_require_slaves,
MENU_ENUM_LABEL_NETPLAY_REQUIRE_SLAVES,
MENU_ENUM_LABEL_VALUE_NETPLAY_REQUIRE_SLAVES,
DEFAULT_NETPLAY_REQUIRE_SLAVES,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
CONFIG_INT(
list, list_info,
&settings->ints.netplay_check_frames,
MENU_ENUM_LABEL_NETPLAY_CHECK_FRAMES,
MENU_ENUM_LABEL_VALUE_NETPLAY_CHECK_FRAMES,
DEFAULT_NETPLAY_CHECK_FRAMES,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
menu_settings_list_current_add_range(list, list_info, 0, 5184000, 1, true, false);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
CONFIG_INT(
list, list_info,
(int *) &settings->uints.netplay_input_latency_frames_min,
MENU_ENUM_LABEL_NETPLAY_INPUT_LATENCY_FRAMES_MIN,
MENU_ENUM_LABEL_VALUE_NETPLAY_INPUT_LATENCY_FRAMES_MIN,
0,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_SPINBOX;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0, 15, 1, true, true);
CONFIG_INT(
list, list_info,
(int *) &settings->uints.netplay_input_latency_frames_range,
MENU_ENUM_LABEL_NETPLAY_INPUT_LATENCY_FRAMES_RANGE,
MENU_ENUM_LABEL_VALUE_NETPLAY_INPUT_LATENCY_FRAMES_RANGE,
0,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_SPINBOX;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0, 15, 1, true, true);
CONFIG_BOOL(
list, list_info,
&settings->bools.netplay_nat_traversal,
MENU_ENUM_LABEL_NETPLAY_NAT_TRAVERSAL,
MENU_ENUM_LABEL_VALUE_NETPLAY_NAT_TRAVERSAL,
true,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
CONFIG_UINT(
list, list_info,
&settings->uints.netplay_share_digital,
MENU_ENUM_LABEL_NETPLAY_SHARE_DIGITAL,
MENU_ENUM_LABEL_VALUE_NETPLAY_SHARE_DIGITAL,
DEFAULT_NETPLAY_SHARE_DIGITAL,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_netplay_share_digital;
menu_settings_list_current_add_range(list, list_info, 0, RARCH_NETPLAY_SHARE_DIGITAL_LAST-1, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
CONFIG_UINT(
list, list_info,
&settings->uints.netplay_share_analog,
MENU_ENUM_LABEL_NETPLAY_SHARE_ANALOG,
MENU_ENUM_LABEL_VALUE_NETPLAY_SHARE_ANALOG,
DEFAULT_NETPLAY_SHARE_ANALOG,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_netplay_share_analog;
menu_settings_list_current_add_range(list, list_info, 0, RARCH_NETPLAY_SHARE_ANALOG_LAST-1, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
for (user = 0; user < MAX_USERS; user++)
{
snprintf(dev_req_label, sizeof(dev_req_label),
msg_hash_to_str(MENU_ENUM_LABEL_NETPLAY_REQUEST_DEVICE_I), user + 1);
snprintf(dev_req_value, sizeof(dev_req_value),
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NETPLAY_REQUEST_DEVICE_I), user + 1);
CONFIG_BOOL_ALT(
list, list_info,
&settings->bools.netplay_request_devices[user],
strdup(dev_req_label),
strdup(dev_req_value),
false,
MENU_ENUM_LABEL_VALUE_NO,
MENU_ENUM_LABEL_VALUE_YES,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED);
SETTINGS_DATA_LIST_CURRENT_ADD_FREE_FLAGS(list, list_info, SD_FREE_FLAG_NAME | SD_FREE_FLAG_SHORT);
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_IDX_PTR(list, list_info, (enum msg_hash_enums)(MENU_ENUM_LABEL_NETPLAY_REQUEST_DEVICE_1 + user));
}
END_SUB_GROUP(list, list_info, parent_group);
START_SUB_GROUP(
list,
list_info,
"Miscellaneous",
&group_info,
&subgroup_info,
parent_group);
#if defined(HAVE_NETWORK_CMD)
CONFIG_BOOL(
list, list_info,
&settings->bools.network_cmd_enable,
MENU_ENUM_LABEL_NETWORK_CMD_ENABLE,
MENU_ENUM_LABEL_VALUE_NETWORK_CMD_ENABLE,
DEFAULT_NETWORK_CMD_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED);
(*list)[list_info->index - 1].action_ok = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_bool_action_right_with_refresh;
CONFIG_UINT(
list, list_info,
&settings->uints.network_cmd_port,
MENU_ENUM_LABEL_NETWORK_CMD_PORT,
MENU_ENUM_LABEL_VALUE_NETWORK_CMD_PORT,
DEFAULT_NETWORK_CMD_PORT,
&group_info,
&subgroup_info,
parent_group,
NULL,
NULL);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].offset_by = 1;
menu_settings_list_current_add_range(list, list_info, 0, 65535, 1, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
CONFIG_BOOL(
list, list_info,
&settings->bools.network_remote_enable,
MENU_ENUM_LABEL_NETWORK_REMOTE_ENABLE,
MENU_ENUM_LABEL_VALUE_NETWORK_REMOTE_ENABLE,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED);
(*list)[list_info->index - 1].action_ok = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_bool_action_right_with_refresh;
CONFIG_UINT(
list, list_info,
&settings->uints.network_remote_base_port,
MENU_ENUM_LABEL_NETWORK_REMOTE_PORT,
MENU_ENUM_LABEL_VALUE_NETWORK_REMOTE_PORT,
DEFAULT_NETWORK_REMOTE_BASE_PORT,
&group_info,
&subgroup_info,
parent_group,
NULL,
NULL);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].offset_by = 1;
menu_settings_list_current_add_range(list, list_info, 0, 65535, 1, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
/* TODO/FIXME - add enum_idx */
{
unsigned max_users = settings->uints.input_max_users;
const char *lbl_network_remote_enable =
msg_hash_to_str(MENU_ENUM_LABEL_NETWORK_REMOTE_ENABLE);
const char *val_network_remote_enable =
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NETWORK_USER_REMOTE_ENABLE);
for (user = 0; user < max_users; user++)
{
char s1[64], s2[64];
size_t _len = strlcpy(s1, lbl_network_remote_enable, sizeof(s1));
snprintf(s1 + _len, sizeof(s1) - _len, "_user_p%d", user + 1);
snprintf(s2, sizeof(s2), val_network_remote_enable, user + 1);
CONFIG_BOOL_ALT(
list, list_info,
&settings->bools.network_remote_enable_user[user],
/* todo: figure out this value, it's working fine but I don't think this is correct */
strdup(s1),
strdup(s2),
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED);
SETTINGS_DATA_LIST_CURRENT_ADD_FREE_FLAGS(list, list_info, SD_FREE_FLAG_NAME | SD_FREE_FLAG_SHORT);
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_IDX_PTR(list, list_info, (enum msg_hash_enums)(MENU_ENUM_LABEL_NETWORK_REMOTE_USER_1_ENABLE + user));
}
}
CONFIG_BOOL(
list, list_info,
&settings->bools.stdin_cmd_enable,
MENU_ENUM_LABEL_STDIN_CMD_ENABLE,
MENU_ENUM_LABEL_VALUE_STDIN_CMD_ENABLE,
DEFAULT_STDIN_CMD_ENABLE,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_ADVANCED);
#endif
CONFIG_BOOL(
list, list_info,
&settings->bools.network_on_demand_thumbnails,
MENU_ENUM_LABEL_NETWORK_ON_DEMAND_THUMBNAILS,
MENU_ENUM_LABEL_VALUE_NETWORK_ON_DEMAND_THUMBNAILS,
DEFAULT_NETWORK_ON_DEMAND_THUMBNAILS,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#endif
}
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
case SETTINGS_LIST_LAKKA_SERVICES:
{
#if defined(HAVE_LAKKA)
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_LAKKA_SERVICES),
parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_SETTINGS);
START_SUB_GROUP(list, list_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_LAKKA_SERVICES),
&group_info, &subgroup_info, parent_group);
CONFIG_BOOL(
list, list_info,
&settings->bools.ssh_enable,
MENU_ENUM_LABEL_SSH_ENABLE,
MENU_ENUM_LABEL_VALUE_SSH_ENABLE,
true,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].change_handler = ssh_enable_toggle_change_handler;
CONFIG_BOOL(
list, list_info,
&settings->bools.samba_enable,
MENU_ENUM_LABEL_SAMBA_ENABLE,
MENU_ENUM_LABEL_VALUE_SAMBA_ENABLE,
true,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].change_handler = samba_enable_toggle_change_handler;
CONFIG_BOOL(
list, list_info,
&settings->bools.bluetooth_enable,
MENU_ENUM_LABEL_BLUETOOTH_ENABLE,
MENU_ENUM_LABEL_VALUE_BLUETOOTH_ENABLE,
true,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].change_handler = bluetooth_enable_toggle_change_handler;
#ifdef HAVE_WIFI
CONFIG_BOOL(
list, list_info,
&settings->bools.localap_enable,
MENU_ENUM_LABEL_LOCALAP_ENABLE,
MENU_ENUM_LABEL_VALUE_LOCALAP_ENABLE,
true,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].change_handler = localap_enable_toggle_change_handler;
#endif
CONFIG_STRING_OPTIONS(
list, list_info,
settings->arrays.timezone,
sizeof(settings->arrays.timezone),
MENU_ENUM_LABEL_TIMEZONE,
MENU_ENUM_LABEL_VALUE_TIMEZONE,
DEFAULT_TIMEZONE,
config_get_all_timezones(),
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_IS_DRIVER);
(*list)[list_info->index - 1].action_ok = setting_action_ok_uint;
(*list)[list_info->index - 1].change_handler = timezone_change_handler;
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
#endif
}
break;
#ifdef HAVE_LAKKA_SWITCH
case SETTINGS_LIST_LAKKA_SWITCH_OPTIONS:
{
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_LAKKA_SWITCH_OPTIONS),
parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_SETTINGS);
START_SUB_GROUP(list, list_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_LAKKA_SWITCH_OPTIONS),
&group_info, &subgroup_info, parent_group);
CONFIG_BOOL(
list, list_info,
&settings->bools.switch_oc,
MENU_ENUM_LABEL_SWITCH_OC_ENABLE,
MENU_ENUM_LABEL_VALUE_SWITCH_OC_ENABLE,
DEFAULT_SWITCH_OC,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].change_handler = switch_oc_enable_toggle_change_handler;
CONFIG_BOOL(
list, list_info,
&settings->bools.switch_cec,
MENU_ENUM_LABEL_SWITCH_CEC_ENABLE,
MENU_ENUM_LABEL_VALUE_SWITCH_CEC_ENABLE,
DEFAULT_SWITCH_CEC,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].change_handler = switch_cec_enable_toggle_change_handler;
CONFIG_BOOL(
list, list_info,
&settings->bools.bluetooth_ertm_disable,
MENU_ENUM_LABEL_BLUETOOTH_ERTM_DISABLE,
MENU_ENUM_LABEL_VALUE_BLUETOOTH_ERTM_DISABLE,
DEFAULT_BLUETOOTH_ERTM,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].change_handler = bluetooth_ertm_disable_toggle_change_handler;
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
}
break;
#endif
case SETTINGS_LIST_USER:
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_USER_SETTINGS),
parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_USER_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_ACCOUNTS_LIST,
MENU_ENUM_LABEL_VALUE_ACCOUNTS_LIST,
&group_info,
&subgroup_info,
parent_group);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
CONFIG_STRING(
list, list_info,
settings->paths.username,
sizeof(settings->paths.username),
MENU_ENUM_LABEL_NETPLAY_NICKNAME,
MENU_ENUM_LABEL_VALUE_NETPLAY_NICKNAME,
"",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_STRING_LINE_EDIT;
(*list)[list_info->index - 1].action_start = setting_generic_action_start_default;
CONFIG_STRING(
list, list_info,
settings->paths.browse_url,
sizeof(settings->paths.browse_url),
MENU_ENUM_LABEL_BROWSE_URL,
MENU_ENUM_LABEL_VALUE_BROWSE_URL,
"",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
(*list)[list_info->index - 1].action_start = setting_generic_action_start_default;
#ifdef HAVE_LANGEXTRA
CONFIG_UINT(
list, list_info,
msg_hash_get_uint(MSG_HASH_USER_LANGUAGE),
MENU_ENUM_LABEL_USER_LANGUAGE,
MENU_ENUM_LABEL_VALUE_USER_LANGUAGE,
DEFAULT_USER_LANGUAGE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
menu_settings_list_current_add_range(
list,
list_info,
0,
RETRO_LANGUAGE_LAST-1,
1,
true,
true);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].action_left = &setting_uint_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_uint_action_right_with_refresh;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_user_language;
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
#endif
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
case SETTINGS_LIST_USER_ACCOUNTS:
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_ACCOUNTS_LIST_END),
parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
#ifdef HAVE_CHEEVOS
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_ACCOUNTS_RETRO_ACHIEVEMENTS,
MENU_ENUM_LABEL_VALUE_ACCOUNTS_RETRO_ACHIEVEMENTS,
&group_info,
&subgroup_info,
parent_group);
#endif
#ifdef HAVE_NETWORKING
#if !IOS
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_ACCOUNTS_YOUTUBE,
MENU_ENUM_LABEL_VALUE_ACCOUNTS_YOUTUBE,
&group_info,
&subgroup_info,
parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_ACCOUNTS_TWITCH,
MENU_ENUM_LABEL_VALUE_ACCOUNTS_TWITCH,
&group_info,
&subgroup_info,
parent_group);
CONFIG_ACTION(
list, list_info,
MENU_ENUM_LABEL_ACCOUNTS_FACEBOOK,
MENU_ENUM_LABEL_VALUE_ACCOUNTS_FACEBOOK,
&group_info,
&subgroup_info,
parent_group);
#endif
#endif
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
case SETTINGS_LIST_USER_ACCOUNTS_YOUTUBE:
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_ACCOUNTS_YOUTUBE),
parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
CONFIG_STRING(
list, list_info,
settings->arrays.youtube_stream_key,
sizeof(settings->arrays.youtube_stream_key),
MENU_ENUM_LABEL_YOUTUBE_STREAM_KEY,
MENU_ENUM_LABEL_VALUE_YOUTUBE_STREAM_KEY,
"",
&group_info,
&subgroup_info,
parent_group,
update_streaming_url_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_STRING_LINE_EDIT;
(*list)[list_info->index - 1].action_start = setting_generic_action_start_default;
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
case SETTINGS_LIST_USER_ACCOUNTS_TWITCH:
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_ACCOUNTS_TWITCH),
parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
CONFIG_STRING(
list, list_info,
settings->arrays.twitch_stream_key,
sizeof(settings->arrays.twitch_stream_key),
MENU_ENUM_LABEL_TWITCH_STREAM_KEY,
MENU_ENUM_LABEL_VALUE_TWITCH_STREAM_KEY,
"",
&group_info,
&subgroup_info,
parent_group,
update_streaming_url_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_STRING_LINE_EDIT;
(*list)[list_info->index - 1].action_start = setting_generic_action_start_default;
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
case SETTINGS_LIST_USER_ACCOUNTS_FACEBOOK:
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_ACCOUNTS_FACEBOOK),
parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
CONFIG_STRING(
list, list_info,
settings->arrays.facebook_stream_key,
sizeof(settings->arrays.facebook_stream_key),
MENU_ENUM_LABEL_FACEBOOK_STREAM_KEY,
MENU_ENUM_LABEL_VALUE_FACEBOOK_STREAM_KEY,
"",
&group_info,
&subgroup_info,
parent_group,
update_streaming_url_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_STRING_LINE_EDIT;
(*list)[list_info->index - 1].action_start = setting_generic_action_start_default;
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
case SETTINGS_LIST_USER_ACCOUNTS_CHEEVOS:
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_ACCOUNTS_CHEEVOS_SETTINGS),
parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
#ifdef HAVE_CHEEVOS
CONFIG_STRING(
list, list_info,
settings->arrays.cheevos_username,
sizeof(settings->arrays.cheevos_username),
MENU_ENUM_LABEL_CHEEVOS_USERNAME,
MENU_ENUM_LABEL_VALUE_ACCOUNTS_CHEEVOS_USERNAME,
"",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_STRING_LINE_EDIT;
(*list)[list_info->index - 1].action_start = setting_generic_action_start_default;
CONFIG_STRING(
list, list_info,
settings->arrays.cheevos_password,
sizeof(settings->arrays.cheevos_password),
MENU_ENUM_LABEL_CHEEVOS_PASSWORD,
MENU_ENUM_LABEL_VALUE_ACCOUNTS_CHEEVOS_PASSWORD,
"",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_password;
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_PASSWORD_LINE_EDIT;
(*list)[list_info->index - 1].action_start = setting_generic_action_start_default;
#endif
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
case SETTINGS_LIST_DIRECTORY:
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_DIRECTORY_SETTINGS),
parent_group);
MENU_SETTINGS_LIST_CURRENT_ADD_ENUM_IDX_PTR(list, list_info, MENU_ENUM_LABEL_DIRECTORY_SETTINGS);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_DIRECTORY_SETTINGS);
START_SUB_GROUP(list, list_info, "State", &group_info, &subgroup_info, parent_group);
CONFIG_DIR(
list, list_info,
settings->paths.directory_system,
sizeof(settings->paths.directory_system),
MENU_ENUM_LABEL_SYSTEM_DIRECTORY,
MENU_ENUM_LABEL_VALUE_SYSTEM_DIRECTORY,
g_defaults.dirs[DEFAULT_DIR_SYSTEM],
MENU_ENUM_LABEL_VALUE_DIRECTORY_CONTENT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
CONFIG_DIR(
list, list_info,
settings->paths.directory_core_assets,
sizeof(settings->paths.directory_core_assets),
MENU_ENUM_LABEL_CORE_ASSETS_DIRECTORY,
MENU_ENUM_LABEL_VALUE_CORE_ASSETS_DIRECTORY,
g_defaults.dirs[DEFAULT_DIR_CORE_ASSETS],
MENU_ENUM_LABEL_VALUE_DIRECTORY_DEFAULT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
CONFIG_DIR(
list, list_info,
settings->paths.directory_assets,
sizeof(settings->paths.directory_assets),
MENU_ENUM_LABEL_ASSETS_DIRECTORY,
MENU_ENUM_LABEL_VALUE_ASSETS_DIRECTORY,
g_defaults.dirs[DEFAULT_DIR_ASSETS],
MENU_ENUM_LABEL_VALUE_DIRECTORY_DEFAULT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
CONFIG_DIR(
list, list_info,
settings->paths.directory_dynamic_wallpapers,
sizeof(settings->paths.directory_dynamic_wallpapers),
MENU_ENUM_LABEL_DYNAMIC_WALLPAPERS_DIRECTORY,
MENU_ENUM_LABEL_VALUE_DYNAMIC_WALLPAPERS_DIRECTORY,
g_defaults.dirs[DEFAULT_DIR_WALLPAPERS],
MENU_ENUM_LABEL_VALUE_DIRECTORY_DEFAULT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
CONFIG_DIR(
list, list_info,
settings->paths.directory_thumbnails,
sizeof(settings->paths.directory_thumbnails),
MENU_ENUM_LABEL_THUMBNAILS_DIRECTORY,
MENU_ENUM_LABEL_VALUE_THUMBNAILS_DIRECTORY,
g_defaults.dirs[DEFAULT_DIR_THUMBNAILS],
MENU_ENUM_LABEL_VALUE_DIRECTORY_DEFAULT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
CONFIG_DIR(
list, list_info,
settings->paths.directory_menu_content,
sizeof(settings->paths.directory_menu_content),
MENU_ENUM_LABEL_RGUI_BROWSER_DIRECTORY,
MENU_ENUM_LABEL_VALUE_RGUI_BROWSER_DIRECTORY,
g_defaults.dirs[DEFAULT_DIR_MENU_CONTENT],
MENU_ENUM_LABEL_VALUE_DIRECTORY_DEFAULT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
CONFIG_DIR(
list, list_info,
settings->paths.directory_menu_config,
sizeof(settings->paths.directory_menu_config),
MENU_ENUM_LABEL_RGUI_CONFIG_DIRECTORY,
MENU_ENUM_LABEL_VALUE_RGUI_CONFIG_DIRECTORY,
g_defaults.dirs[DEFAULT_DIR_MENU_CONFIG],
MENU_ENUM_LABEL_VALUE_DIRECTORY_DEFAULT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
CONFIG_DIR(
list, list_info,
settings->paths.directory_libretro,
sizeof(settings->paths.directory_libretro),
MENU_ENUM_LABEL_LIBRETRO_DIR_PATH,
MENU_ENUM_LABEL_VALUE_LIBRETRO_DIR_PATH,
g_defaults.dirs[DEFAULT_DIR_CORE],
MENU_ENUM_LABEL_VALUE_DIRECTORY_NONE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_CORE_INFO_INIT);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
CONFIG_DIR(
list, list_info,
settings->paths.path_libretro_info,
sizeof(settings->paths.path_libretro_info),
MENU_ENUM_LABEL_LIBRETRO_INFO_PATH,
MENU_ENUM_LABEL_VALUE_LIBRETRO_INFO_PATH,
g_defaults.dirs[DEFAULT_DIR_CORE_INFO],
MENU_ENUM_LABEL_VALUE_DIRECTORY_NONE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_CORE_INFO_INIT);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
#ifdef HAVE_LIBRETRODB
CONFIG_DIR(
list, list_info,
settings->paths.path_content_database,
sizeof(settings->paths.path_content_database),
MENU_ENUM_LABEL_CONTENT_DATABASE_DIRECTORY,
MENU_ENUM_LABEL_VALUE_CONTENT_DATABASE_DIRECTORY,
g_defaults.dirs[DEFAULT_DIR_DATABASE],
MENU_ENUM_LABEL_VALUE_DIRECTORY_NONE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
#endif
CONFIG_DIR(
list, list_info,
settings->paths.path_cheat_database,
sizeof(settings->paths.path_cheat_database),
MENU_ENUM_LABEL_CHEAT_DATABASE_PATH,
MENU_ENUM_LABEL_VALUE_CHEAT_DATABASE_PATH,
g_defaults.dirs[DEFAULT_DIR_CHEATS],
MENU_ENUM_LABEL_VALUE_DIRECTORY_NONE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
CONFIG_DIR(
list, list_info,
settings->paths.directory_video_filter,
sizeof(settings->paths.directory_video_filter),
MENU_ENUM_LABEL_VIDEO_FILTER_DIR,
MENU_ENUM_LABEL_VALUE_VIDEO_FILTER_DIR,
g_defaults.dirs[DEFAULT_DIR_VIDEO_FILTER],
MENU_ENUM_LABEL_VALUE_DIRECTORY_DEFAULT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
CONFIG_DIR(
list, list_info,
settings->paths.directory_audio_filter,
sizeof(settings->paths.directory_audio_filter),
MENU_ENUM_LABEL_AUDIO_FILTER_DIR,
MENU_ENUM_LABEL_VALUE_AUDIO_FILTER_DIR,
g_defaults.dirs[DEFAULT_DIR_AUDIO_FILTER],
MENU_ENUM_LABEL_VALUE_DIRECTORY_DEFAULT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
CONFIG_DIR(
list, list_info,
settings->paths.directory_video_shader,
sizeof(settings->paths.directory_video_shader),
MENU_ENUM_LABEL_VIDEO_SHADER_DIR,
MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_DIR,
g_defaults.dirs[DEFAULT_DIR_SHADER],
MENU_ENUM_LABEL_VALUE_DIRECTORY_DEFAULT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
#endif
if (string_is_not_equal(settings->arrays.record_driver, "null"))
{
CONFIG_DIR(
list, list_info,
recording_st->output_dir,
sizeof(recording_st->output_dir),
MENU_ENUM_LABEL_RECORDING_OUTPUT_DIRECTORY,
MENU_ENUM_LABEL_VALUE_RECORDING_OUTPUT_DIRECTORY,
g_defaults.dirs[DEFAULT_DIR_RECORD_OUTPUT],
MENU_ENUM_LABEL_VALUE_DIRECTORY_DEFAULT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
CONFIG_DIR(
list, list_info,
recording_st->config_dir,
sizeof(recording_st->config_dir),
MENU_ENUM_LABEL_RECORDING_CONFIG_DIRECTORY,
MENU_ENUM_LABEL_VALUE_RECORDING_CONFIG_DIRECTORY,
g_defaults.dirs[DEFAULT_DIR_RECORD_CONFIG],
MENU_ENUM_LABEL_VALUE_DIRECTORY_DEFAULT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
}
#ifdef HAVE_OVERLAY
CONFIG_DIR(
list, list_info,
settings->paths.directory_overlay,
sizeof(settings->paths.directory_overlay),
MENU_ENUM_LABEL_OVERLAY_DIRECTORY,
MENU_ENUM_LABEL_VALUE_OVERLAY_DIRECTORY,
g_defaults.dirs[DEFAULT_DIR_OVERLAY],
MENU_ENUM_LABEL_VALUE_DIRECTORY_DEFAULT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
CONFIG_DIR(
list, list_info,
settings->paths.directory_osk_overlay,
sizeof(settings->paths.directory_osk_overlay),
MENU_ENUM_LABEL_OSK_OVERLAY_DIRECTORY,
MENU_ENUM_LABEL_VALUE_OSK_OVERLAY_DIRECTORY,
g_defaults.dirs[DEFAULT_DIR_OSK_OVERLAY],
MENU_ENUM_LABEL_VALUE_DIRECTORY_DEFAULT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
#endif
CONFIG_DIR(
list, list_info,
settings->paths.directory_screenshot,
sizeof(settings->paths.directory_screenshot),
MENU_ENUM_LABEL_SCREENSHOT_DIRECTORY,
MENU_ENUM_LABEL_VALUE_SCREENSHOT_DIRECTORY,
g_defaults.dirs[DEFAULT_DIR_SCREENSHOT],
MENU_ENUM_LABEL_VALUE_DIRECTORY_CONTENT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
CONFIG_DIR(
list, list_info,
settings->paths.directory_autoconfig,
sizeof(settings->paths.directory_autoconfig),
MENU_ENUM_LABEL_JOYPAD_AUTOCONFIG_DIR,
MENU_ENUM_LABEL_VALUE_JOYPAD_AUTOCONFIG_DIR,
g_defaults.dirs[DEFAULT_DIR_AUTOCONFIG],
MENU_ENUM_LABEL_VALUE_DIRECTORY_DEFAULT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
CONFIG_DIR(
list, list_info,
settings->paths.directory_input_remapping,
sizeof(settings->paths.directory_input_remapping),
MENU_ENUM_LABEL_INPUT_REMAPPING_DIRECTORY,
MENU_ENUM_LABEL_VALUE_INPUT_REMAPPING_DIRECTORY,
g_defaults.dirs[DEFAULT_DIR_REMAP],
MENU_ENUM_LABEL_VALUE_DIRECTORY_NONE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
CONFIG_DIR(
list, list_info,
settings->paths.directory_playlist,
sizeof(settings->paths.directory_playlist),
MENU_ENUM_LABEL_PLAYLIST_DIRECTORY,
MENU_ENUM_LABEL_VALUE_PLAYLIST_DIRECTORY,
g_defaults.dirs[DEFAULT_DIR_PLAYLIST],
MENU_ENUM_LABEL_VALUE_DIRECTORY_DEFAULT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
CONFIG_DIR(
list, list_info,
settings->paths.directory_content_favorites,
sizeof(settings->paths.directory_content_favorites),
MENU_ENUM_LABEL_CONTENT_FAVORITES_DIRECTORY,
MENU_ENUM_LABEL_VALUE_CONTENT_FAVORITES_DIRECTORY,
g_defaults.dirs[DEFAULT_DIR_CONTENT_FAVORITES],
MENU_ENUM_LABEL_VALUE_DIRECTORY_DEFAULT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
CONFIG_DIR(
list, list_info,
settings->paths.directory_content_history,
sizeof(settings->paths.directory_content_history),
MENU_ENUM_LABEL_CONTENT_HISTORY_DIRECTORY,
MENU_ENUM_LABEL_VALUE_CONTENT_HISTORY_DIRECTORY,
g_defaults.dirs[DEFAULT_DIR_CONTENT_HISTORY],
MENU_ENUM_LABEL_VALUE_DIRECTORY_DEFAULT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
CONFIG_DIR(
list, list_info,
settings->paths.directory_content_image_history,
sizeof(settings->paths.directory_content_image_history),
MENU_ENUM_LABEL_CONTENT_IMAGE_HISTORY_DIRECTORY,
MENU_ENUM_LABEL_VALUE_CONTENT_IMAGE_HISTORY_DIRECTORY,
g_defaults.dirs[DEFAULT_DIR_CONTENT_IMAGE_HISTORY],
MENU_ENUM_LABEL_VALUE_DIRECTORY_DEFAULT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
CONFIG_DIR(
list, list_info,
settings->paths.directory_content_music_history,
sizeof(settings->paths.directory_content_music_history),
MENU_ENUM_LABEL_CONTENT_MUSIC_HISTORY_DIRECTORY,
MENU_ENUM_LABEL_VALUE_CONTENT_MUSIC_HISTORY_DIRECTORY,
g_defaults.dirs[DEFAULT_DIR_CONTENT_MUSIC_HISTORY],
MENU_ENUM_LABEL_VALUE_DIRECTORY_DEFAULT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
CONFIG_DIR(
list, list_info,
settings->paths.directory_content_video_history,
sizeof(settings->paths.directory_content_video_history),
MENU_ENUM_LABEL_CONTENT_VIDEO_HISTORY_DIRECTORY,
MENU_ENUM_LABEL_VALUE_CONTENT_VIDEO_HISTORY_DIRECTORY,
g_defaults.dirs[DEFAULT_DIR_CONTENT_VIDEO_HISTORY],
MENU_ENUM_LABEL_VALUE_DIRECTORY_DEFAULT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
CONFIG_DIR(
list, list_info,
settings->paths.directory_runtime_log,
sizeof(settings->paths.directory_runtime_log),
MENU_ENUM_LABEL_RUNTIME_LOG_DIRECTORY,
MENU_ENUM_LABEL_VALUE_RUNTIME_LOG_DIRECTORY,
"",
MENU_ENUM_LABEL_VALUE_DIRECTORY_DEFAULT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
CONFIG_DIR(
list, list_info,
dir_get_ptr(RARCH_DIR_SAVEFILE),
dir_get_size(RARCH_DIR_SAVEFILE),
MENU_ENUM_LABEL_SAVEFILE_DIRECTORY,
MENU_ENUM_LABEL_VALUE_SAVEFILE_DIRECTORY,
g_defaults.dirs[DEFAULT_DIR_SRAM],
MENU_ENUM_LABEL_VALUE_DIRECTORY_CONTENT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
CONFIG_DIR(
list, list_info,
dir_get_ptr(RARCH_DIR_SAVESTATE),
dir_get_size(RARCH_DIR_SAVESTATE),
MENU_ENUM_LABEL_SAVESTATE_DIRECTORY,
MENU_ENUM_LABEL_VALUE_SAVESTATE_DIRECTORY,
g_defaults.dirs[DEFAULT_DIR_SAVESTATE],
MENU_ENUM_LABEL_VALUE_DIRECTORY_CONTENT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
CONFIG_DIR(
list, list_info,
settings->paths.directory_cache,
sizeof(settings->paths.directory_cache),
MENU_ENUM_LABEL_CACHE_DIRECTORY,
MENU_ENUM_LABEL_VALUE_CACHE_DIRECTORY,
g_defaults.dirs[DEFAULT_DIR_CACHE],
MENU_ENUM_LABEL_VALUE_DIRECTORY_NONE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
CONFIG_DIR(
list, list_info,
settings->paths.log_dir,
sizeof(settings->paths.log_dir),
MENU_ENUM_LABEL_LOG_DIR,
MENU_ENUM_LABEL_VALUE_LOG_DIR,
g_defaults.dirs[DEFAULT_DIR_LOGS],
MENU_ENUM_LABEL_VALUE_DIRECTORY_DEFAULT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_start = directory_action_start_generic;
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
case SETTINGS_LIST_PRIVACY:
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_PRIVACY_SETTINGS), parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_PRIVACY_SETTINGS);
START_SUB_GROUP(list, list_info, "State",
&group_info, &subgroup_info, parent_group);
if (string_is_not_equal(settings->arrays.camera_driver, "null"))
{
CONFIG_BOOL(
list, list_info,
&settings->bools.camera_allow,
MENU_ENUM_LABEL_CAMERA_ALLOW,
MENU_ENUM_LABEL_VALUE_CAMERA_ALLOW,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
}
#ifdef HAVE_DISCORD
CONFIG_BOOL(
list, list_info,
&settings->bools.discord_enable,
MENU_ENUM_LABEL_DISCORD_ALLOW,
MENU_ENUM_LABEL_VALUE_DISCORD_ALLOW,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
#endif
if (string_is_not_equal(settings->arrays.location_driver, "null"))
{
CONFIG_BOOL(
list, list_info,
&settings->bools.location_allow,
MENU_ENUM_LABEL_LOCATION_ALLOW,
MENU_ENUM_LABEL_VALUE_LOCATION_ALLOW,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
}
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
case SETTINGS_LIST_MIDI:
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_MIDI_SETTINGS), parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_MIDI_SETTINGS);
START_SUB_GROUP(list, list_info, "State",
&group_info, &subgroup_info, parent_group);
CONFIG_STRING(
list, list_info,
settings->arrays.midi_input,
sizeof(settings->arrays.midi_input),
MENU_ENUM_LABEL_MIDI_INPUT,
MENU_ENUM_LABEL_VALUE_MIDI_INPUT,
DEFAULT_MIDI_INPUT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
(*list)[list_info->index - 1].action_start = setting_generic_action_start_default;
(*list)[list_info->index - 1].action_left = setting_string_action_left_midi_input;
(*list)[list_info->index - 1].action_right = setting_string_action_right_midi_input;
CONFIG_STRING(
list, list_info,
settings->arrays.midi_output,
sizeof(settings->arrays.midi_output),
MENU_ENUM_LABEL_MIDI_OUTPUT,
MENU_ENUM_LABEL_VALUE_MIDI_OUTPUT,
DEFAULT_MIDI_OUTPUT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
(*list)[list_info->index - 1].action_start = setting_generic_action_start_default;
(*list)[list_info->index - 1].action_left = setting_string_action_left_midi_output;
(*list)[list_info->index - 1].action_right = setting_string_action_right_midi_output;
CONFIG_UINT(
list, list_info,
&settings->uints.midi_volume,
MENU_ENUM_LABEL_MIDI_VOLUME,
MENU_ENUM_LABEL_VALUE_MIDI_VOLUME,
DEFAULT_MIDI_VOLUME,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0.0f, 100.0f, 1.0f, true, true);
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
case SETTINGS_LIST_MANUAL_CONTENT_SCAN:
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_MANUAL_CONTENT_SCAN_LIST), parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_MANUAL_CONTENT_SCAN_LIST);
START_SUB_GROUP(list, list_info, "State",
&group_info, &subgroup_info, parent_group);
CONFIG_STRING(
list, list_info,
manual_content_scan_get_system_name_custom_ptr(),
manual_content_scan_get_system_name_custom_size(),
MENU_ENUM_LABEL_MANUAL_CONTENT_SCAN_SYSTEM_NAME_CUSTOM,
MENU_ENUM_LABEL_VALUE_MANUAL_CONTENT_SCAN_SYSTEM_NAME_CUSTOM,
"",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_STRING_LINE_EDIT;
(*list)[list_info->index - 1].action_start = setting_generic_action_start_default;
CONFIG_STRING(
list, list_info,
manual_content_scan_get_file_exts_custom_ptr(),
manual_content_scan_get_file_exts_custom_size(),
MENU_ENUM_LABEL_MANUAL_CONTENT_SCAN_FILE_EXTS,
MENU_ENUM_LABEL_VALUE_MANUAL_CONTENT_SCAN_FILE_EXTS,
"",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ALLOW_INPUT);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_STRING_LINE_EDIT;
(*list)[list_info->index - 1].action_start = setting_generic_action_start_default;
CONFIG_BOOL(
list, list_info,
manual_content_scan_get_search_recursively_ptr(),
MENU_ENUM_LABEL_MANUAL_CONTENT_SCAN_SEARCH_RECURSIVELY,
MENU_ENUM_LABEL_VALUE_MANUAL_CONTENT_SCAN_SEARCH_RECURSIVELY,
true,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
manual_content_scan_get_search_archives_ptr(),
MENU_ENUM_LABEL_MANUAL_CONTENT_SCAN_SEARCH_ARCHIVES,
MENU_ENUM_LABEL_VALUE_MANUAL_CONTENT_SCAN_SEARCH_ARCHIVES,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_PATH(
list, list_info,
manual_content_scan_get_dat_file_path_ptr(),
manual_content_scan_get_dat_file_path_size(),
MENU_ENUM_LABEL_MANUAL_CONTENT_SCAN_DAT_FILE,
MENU_ENUM_LABEL_VALUE_MANUAL_CONTENT_SCAN_DAT_FILE,
"",
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
MENU_SETTINGS_LIST_CURRENT_ADD_VALUES(list, list_info, "dat|xml");
CONFIG_BOOL(
list, list_info,
manual_content_scan_get_filter_dat_content_ptr(),
MENU_ENUM_LABEL_MANUAL_CONTENT_SCAN_DAT_FILE_FILTER,
MENU_ENUM_LABEL_VALUE_MANUAL_CONTENT_SCAN_DAT_FILE_FILTER,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
CONFIG_BOOL(
list, list_info,
manual_content_scan_get_overwrite_playlist_ptr(),
MENU_ENUM_LABEL_MANUAL_CONTENT_SCAN_OVERWRITE,
MENU_ENUM_LABEL_VALUE_MANUAL_CONTENT_SCAN_OVERWRITE,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].action_ok = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = setting_bool_action_right_with_refresh;
CONFIG_BOOL(
list, list_info,
manual_content_scan_get_validate_entries_ptr(),
MENU_ENUM_LABEL_MANUAL_CONTENT_SCAN_VALIDATE_ENTRIES,
MENU_ENUM_LABEL_VALUE_MANUAL_CONTENT_SCAN_VALIDATE_ENTRIES,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
#ifdef HAVE_MIST
case SETTINGS_LIST_STEAM:
START_GROUP(list, list_info, &group_info,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_STEAM_SETTINGS), parent_group);
parent_group = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_STEAM_SETTINGS);
START_SUB_GROUP(list, list_info, "State",
&group_info, &subgroup_info, parent_group);
CONFIG_BOOL(
list, list_info,
&settings->bools.steam_rich_presence_enable,
MENU_ENUM_LABEL_STEAM_RICH_PRESENCE_ENABLE,
MENU_ENUM_LABEL_VALUE_STEAM_RICH_PRESENCE_ENABLE,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
(*list)[list_info->index - 1].action_ok = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_left = &setting_bool_action_left_with_refresh;
(*list)[list_info->index - 1].action_right = &setting_bool_action_right_with_refresh;
CONFIG_UINT(
list, list_info,
&settings->uints.steam_rich_presence_format,
MENU_ENUM_LABEL_STEAM_RICH_PRESENCE_FORMAT,
MENU_ENUM_LABEL_VALUE_STEAM_RICH_PRESENCE_FORMAT,
DEFAULT_STEAM_RICH_PRESENCE_FORMAT,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_steam_rich_presence_format;
menu_settings_list_current_add_range(list, list_info, 0, (STEAM_RICH_PRESENCE_FORMAT_LAST-1), 1, true, true);
END_SUB_GROUP(list, list_info, parent_group);
END_GROUP(list, list_info, parent_group);
break;
#endif
case SETTINGS_LIST_NONE:
default:
break;
}
return true;
}
void menu_setting_free(rarch_setting_t *setting)
{
unsigned values, n;
rarch_setting_t **list = NULL;
if (!setting)
return;
list = (rarch_setting_t**)&setting;
/* Free data which was previously tagged */
for (; setting->type != ST_NONE; (*list = *list + 1))
for (values = setting->free_flags, n = 0; values != 0; values >>= 1, n++)
if (values & 1)
switch (1 << n)
{
case SD_FREE_FLAG_VALUES:
if (setting->values)
free((void*)setting->values);
setting->values = NULL;
break;
case SD_FREE_FLAG_NAME:
if (setting->name)
free((void*)setting->name);
setting->name = NULL;
break;
case SD_FREE_FLAG_SHORT:
if (setting->short_description)
free((void*)setting->short_description);
setting->short_description = NULL;
break;
default:
break;
}
}
#define MENU_SETTING_INITIALIZE(list, _pos) \
{ \
unsigned pos = _pos; \
(*&list)[pos].ui_type = ST_UI_TYPE_NONE; \
(*&list)[pos].browser_selection_type = ST_NONE; \
(*&list)[pos].enum_idx = MSG_UNKNOWN; \
(*&list)[pos].enum_value_idx = MSG_UNKNOWN; \
(*&list)[pos].type = ST_NONE; \
(*&list)[pos].index = 0; \
(*&list)[pos].index_offset = 0; \
(*&list)[pos].offset_by = 0; \
(*&list)[pos].bind_type = 0; \
(*&list)[pos].size = 0; \
(*&list)[pos].step = 0.0f; \
(*&list)[pos].flags = 0; \
(*&list)[pos].free_flags = 0; \
(*&list)[pos].min = 0.0; \
(*&list)[pos].max = 0.0; \
(*&list)[pos].rounding_fraction = NULL; \
(*&list)[pos].name = NULL; \
(*&list)[pos].short_description = NULL; \
(*&list)[pos].group = NULL; \
(*&list)[pos].subgroup = NULL; \
(*&list)[pos].parent_group = NULL; \
(*&list)[pos].values = NULL; \
(*&list)[pos].change_handler = NULL; \
(*&list)[pos].read_handler = NULL; \
(*&list)[pos].action_start = NULL; \
(*&list)[pos].action_left = NULL; \
(*&list)[pos].action_right = NULL; \
(*&list)[pos].action_up = NULL; \
(*&list)[pos].action_down = NULL; \
(*&list)[pos].action_cancel = NULL; \
(*&list)[pos].action_ok = NULL; \
(*&list)[pos].action_select = NULL; \
(*&list)[pos].get_string_representation = NULL; \
(*&list)[pos].default_value.fraction = 0.0f; \
(*&list)[pos].value.target.fraction = NULL; \
(*&list)[pos].original_value.fraction = 0.0f; \
(*&list)[pos].dir.empty_path = NULL; \
(*&list)[pos].cmd_trigger_idx = CMD_EVENT_NONE; \
(*&list)[pos].boolean.off_label = NULL; \
(*&list)[pos].boolean.on_label = NULL; \
}
static rarch_setting_t *menu_setting_new_internal(rarch_setting_info_t *list_info)
{
unsigned i;
rarch_setting_t* resized_list = NULL;
enum settings_list_type list_types[] =
{
SETTINGS_LIST_MAIN_MENU,
SETTINGS_LIST_DRIVERS,
SETTINGS_LIST_CORE,
SETTINGS_LIST_CONFIGURATION,
SETTINGS_LIST_LOGGING,
SETTINGS_LIST_SAVING,
SETTINGS_LIST_CLOUD_SYNC,
SETTINGS_LIST_REWIND,
SETTINGS_LIST_CHEAT_DETAILS,
SETTINGS_LIST_CHEAT_SEARCH,
SETTINGS_LIST_CHEATS,
SETTINGS_LIST_VIDEO,
SETTINGS_LIST_CRT_SWITCHRES,
SETTINGS_LIST_AUDIO,
#ifdef HAVE_MICROPHONE
SETTINGS_LIST_MICROPHONE,
#endif
SETTINGS_LIST_INPUT,
SETTINGS_LIST_INPUT_TURBO_FIRE,
SETTINGS_LIST_INPUT_HOTKEY,
SETTINGS_LIST_RECORDING,
SETTINGS_LIST_FRAME_THROTTLING,
SETTINGS_LIST_FRAME_TIME_COUNTER,
SETTINGS_LIST_ONSCREEN_NOTIFICATIONS,
SETTINGS_LIST_OVERLAY,
SETTINGS_LIST_OSK_OVERLAY,
SETTINGS_LIST_OVERLAY_MOUSE,
SETTINGS_LIST_OVERLAY_LIGHTGUN,
SETTINGS_LIST_MENU,
SETTINGS_LIST_MENU_FILE_BROWSER,
SETTINGS_LIST_MULTIMEDIA,
#ifdef HAVE_TRANSLATE
SETTINGS_LIST_AI_SERVICE,
#endif
SETTINGS_LIST_ACCESSIBILITY,
SETTINGS_LIST_USER_INTERFACE,
SETTINGS_LIST_POWER_MANAGEMENT,
SETTINGS_LIST_WIFI_MANAGEMENT,
SETTINGS_LIST_MENU_SOUNDS,
SETTINGS_LIST_PLAYLIST,
SETTINGS_LIST_CHEEVOS,
SETTINGS_LIST_CHEEVOS_APPEARANCE,
SETTINGS_LIST_CHEEVOS_VISIBILITY,
SETTINGS_LIST_CORE_UPDATER,
SETTINGS_LIST_NETPLAY,
SETTINGS_LIST_LAKKA_SERVICES,
#ifdef HAVE_LAKKA_SWITCH
SETTINGS_LIST_LAKKA_SWITCH_OPTIONS,
#endif
SETTINGS_LIST_USER,
SETTINGS_LIST_USER_ACCOUNTS,
SETTINGS_LIST_USER_ACCOUNTS_CHEEVOS,
SETTINGS_LIST_USER_ACCOUNTS_YOUTUBE,
SETTINGS_LIST_USER_ACCOUNTS_TWITCH,
SETTINGS_LIST_USER_ACCOUNTS_FACEBOOK,
SETTINGS_LIST_DIRECTORY,
SETTINGS_LIST_PRIVACY,
SETTINGS_LIST_MIDI,
#ifdef HAVE_MIST
SETTINGS_LIST_STEAM,
#endif
SETTINGS_LIST_MANUAL_CONTENT_SCAN
};
settings_t *settings = config_get_ptr();
global_t *global = global_get_ptr();
const char *root = NULL;
rarch_setting_t **list_ptr = NULL;
rarch_setting_t *list = (rarch_setting_t*)
malloc(list_info->size * sizeof(*list));
if (!list)
return NULL;
root =
msg_hash_to_str(MENU_ENUM_LABEL_MAIN_MENU);
for (i = 0; i < (unsigned)list_info->size; i++)
{
MENU_SETTING_INITIALIZE(list, i);
}
for (i = 0; i < ARRAY_SIZE(list_types); i++)
{
if (!setting_append_list(
settings, global,
list_types[i], &list, list_info, root))
{
free(list);
return NULL;
}
}
list_ptr = &list;
if (!SETTINGS_LIST_APPEND(list_ptr, list_info))
{
free(list);
return NULL;
}
MENU_SETTING_INITIALIZE(list, list_info->index);
list_info->index++;
/* flatten this array to save ourselves some kilobytes. */
resized_list = (rarch_setting_t*)realloc(list,
list_info->index * sizeof(rarch_setting_t));
if (!resized_list)
{
free(list);
return NULL;
}
list = resized_list;
return list;
}
/**
* menu_setting_new:
* @mask : Bitmask of settings to include.
*
* Request a list of settings based on @mask.
*
* Returns: settings list composed of all requested
* settings on success, otherwise NULL.
**/
rarch_setting_t *menu_setting_new(void)
{
rarch_setting_t* list = NULL;
rarch_setting_info_t *list_info = (rarch_setting_info_t*)
malloc(sizeof(*list_info));
if (!list_info)
return NULL;
list_info->index = 0;
list_info->size = 32;
list = menu_setting_new_internal(list_info);
if (list_info)
free(list_info);
list_info = NULL;
return list;
}
void video_driver_menu_settings(void **list_data, void *list_info_data,
void *group_data, void *subgroup_data, const char *parent_group)
{
#ifdef HAVE_MENU
rarch_setting_t **list = (rarch_setting_t**)list_data;
rarch_setting_info_t *list_info = (rarch_setting_info_t*)list_info_data;
rarch_setting_group_info_t *group_info = (rarch_setting_group_info_t*)group_data;
rarch_setting_group_info_t *subgroup_info = (rarch_setting_group_info_t*)subgroup_data;
global_t *global = global_get_ptr();
(void)list;
(void)list_info;
(void)group_info;
(void)subgroup_info;
(void)global;
#if defined(GEKKO) || defined(_XBOX360)
CONFIG_UINT(
list, list_info,
&global->console.screen.gamma_correction,
MENU_ENUM_LABEL_VIDEO_GAMMA,
MENU_ENUM_LABEL_VALUE_VIDEO_GAMMA,
0,
group_info,
subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(
list,
list_info,
CMD_EVENT_VIDEO_APPLY_STATE_CHANGES);
menu_settings_list_current_add_range(
list,
list_info,
0,
MAX_GAMMA_SETTING,
1,
true,
true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info,
SD_FLAG_CMD_APPLY_AUTO|SD_FLAG_ADVANCED);
#endif
#if defined(_XBOX1) || defined(HW_RVL)
CONFIG_BOOL(
list, list_info,
&global->console.softfilter_enable,
MENU_ENUM_LABEL_VIDEO_SOFT_FILTER,
MENU_ENUM_LABEL_VALUE_VIDEO_SOFT_FILTER,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
group_info,
subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
MENU_SETTINGS_LIST_CURRENT_ADD_CMD(
list,
list_info,
CMD_EVENT_VIDEO_APPLY_STATE_CHANGES);
#endif
#ifdef _XBOX1
CONFIG_UINT(
list, list_info,
&global->console.screen.flicker_filter_index,
MENU_ENUM_LABEL_VIDEO_FILTER_FLICKER,
MENU_ENUM_LABEL_VALUE_VIDEO_FILTER_FLICKER,
0,
group_info,
subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
menu_settings_list_current_add_range(list, list_info,
0, 5, 1, true, true);
#endif
#endif
}