libretro/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch.git synced 2024-12-11 18:23:45 +00:00
Code Issues Actions 23 Packages Projects Releases Wiki Activity
ed6f33b173
RetroArch/core_option_manager.c

1854 lines
53 KiB
C
Raw Blame History

/* RetroArch - A frontend for libretro.
* Copyright (C) 2010-2014 - Hans-Kristian Arntzen
* Copyright (C) 2011-2017 - Daniel De Matteis
*
* RetroArch is free software: you can redistribute it and/or modify it under the terms
* of the GNU General Public License as published by the Free Software Found-
* ation, either version 3 of the License, or (at your option) any later version.
*
* RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with RetroArch.
* If not, see <http://www.gnu.org/licenses/>.
*/
#include <string/stdstring.h>
#ifdef HAVE_CHEEVOS
#include "cheevos/cheevos.h"
#endif
#ifdef HAVE_MENU
#include "menu/menu_driver.h"
#endif
#include "core_option_manager.h"
#define CORE_OPTION_MANAGER_MAP_TAG "#"
#define CORE_OPTION_MANAGER_MAP_DELIM ":"
/*********************/
/* Option Conversion */
/*********************/
/**
* core_option_manager_convert_v1:
*
* @options_v1 : an array of retro_core_option_definition
* structs
*
* Converts an array of core option v1 definitions into
* a v2 core options struct. Returned pointer must be
* freed using core_option_manager_free_converted().
*
* Returns: Valid pointer to a new v2 core options struct
* if successful, otherwise NULL.
**/
struct retro_core_options_v2 *core_option_manager_convert_v1(
const struct retro_core_option_definition *options_v1)
{
size_t i;
size_t num_options = 0;
struct retro_core_options_v2 *options_v2 = NULL;
struct retro_core_option_v2_definition *option_v2_defs = NULL;
if (!options_v1)
return NULL;
/* Determine number of options */
for (;;)
{
if (string_is_empty(options_v1[num_options].key))
break;
num_options++;
}
if (num_options < 1)
return NULL;
/* Allocate output retro_core_options_v2 struct */
options_v2 = (struct retro_core_options_v2 *)
malloc(sizeof(*options_v2));
if (!options_v2)
return NULL;
/* Note: v1 options have no concept of
* categories, so this field will be left
* as NULL */
options_v2->categories = NULL;
options_v2->definitions = NULL;
/* Allocate output option_v2_defs array
* > One extra entry required for terminating NULL entry
* > Note that calloc() sets terminating NULL entry and
* correctly 'nullifies' each values array */
option_v2_defs = (struct retro_core_option_v2_definition *)
calloc(num_options + 1, sizeof(*option_v2_defs));
if (!option_v2_defs)
{
free(options_v2);
return NULL;
}
options_v2->definitions = option_v2_defs;
/* Loop through options... */
for (i = 0; i < num_options; i++)
{
size_t j;
size_t num_values = 0;
/* Set key */
option_v2_defs[i].key = options_v1[i].key;
/* Set default value */
option_v2_defs[i].default_value = options_v1[i].default_value;
/* Set desc and info strings */
option_v2_defs[i].desc = options_v1[i].desc;
option_v2_defs[i].info = options_v1[i].info;
/* v1 options have no concept of categories
* (Note: These are already nullified by
* the preceding calloc(), but we do it
* explicitly here for code clarity) */
option_v2_defs[i].desc_categorized = NULL;
option_v2_defs[i].info_categorized = NULL;
option_v2_defs[i].category_key = NULL;
/* Determine number of values */
for (;;)
{
if (string_is_empty(options_v1[i].values[num_values].value))
break;
num_values++;
}
/* Copy values */
for (j = 0; j < num_values; j++)
{
/* Set value string */
option_v2_defs[i].values[j].value = options_v1[i].values[j].value;
/* Set value label string */
option_v2_defs[i].values[j].label = options_v1[i].values[j].label;
}
}
return options_v2;
}
/**
* core_option_manager_convert_v1_intl:
*
* @options_v1_intl : pointer to a retro_core_options_intl
* struct
*
* Converts a v1 'international' core options definition
* struct into a v2 core options struct. Returned pointer
* must be freed using core_option_manager_free_converted().
*
* Returns: Valid pointer to a new v2 core options struct
* if successful, otherwise NULL.
**/
struct retro_core_options_v2 *core_option_manager_convert_v1_intl(
const struct retro_core_options_intl *options_v1_intl)
{
size_t i;
size_t num_options = 0;
struct retro_core_option_definition *option_defs_us = NULL;
struct retro_core_option_definition *option_defs_local = NULL;
struct retro_core_options_v2 *options_v2 = NULL;
struct retro_core_option_v2_definition *option_v2_defs = NULL;
if (!options_v1_intl)
return NULL;
option_defs_us = options_v1_intl->us;
option_defs_local = options_v1_intl->local;
if (!option_defs_us)
return NULL;
/* Determine number of options */
for (;;)
{
if (string_is_empty(option_defs_us[num_options].key))
break;
num_options++;
}
if (num_options < 1)
return NULL;
/* Allocate output retro_core_options_v2 struct */
options_v2 = (struct retro_core_options_v2 *)
malloc(sizeof(*options_v2));
if (!options_v2)
return NULL;
/* Note: v1 options have no concept of
* categories, so this field will be left
* as NULL */
options_v2->categories = NULL;
options_v2->definitions = NULL;
/* Allocate output option_v2_defs array
* > One extra entry required for terminating NULL entry
* > Note that calloc() sets terminating NULL entry and
* correctly 'nullifies' each values array */
option_v2_defs = (struct retro_core_option_v2_definition *)
calloc(num_options + 1, sizeof(*option_v2_defs));
if (!option_v2_defs)
{
core_option_manager_free_converted(options_v2);
return NULL;
}
options_v2->definitions = option_v2_defs;
/* Loop through options... */
for (i = 0; i < num_options; i++)
{
size_t j;
size_t num_values = 0;
const char *key = option_defs_us[i].key;
const char *local_desc = NULL;
const char *local_info = NULL;
struct retro_core_option_value *local_values = NULL;
/* Key is always taken from us english defs */
option_v2_defs[i].key = key;
/* Default value is always taken from us english defs */
option_v2_defs[i].default_value = option_defs_us[i].default_value;
/* Try to find corresponding entry in local defs array */
if (option_defs_local)
{
size_t index = 0;
for (;;)
{
const char *local_key = option_defs_local[index].key;
if (string_is_empty(local_key))
break;
if (string_is_equal(key, local_key))
{
local_desc = option_defs_local[index].desc;
local_info = option_defs_local[index].info;
local_values = option_defs_local[index].values;
break;
}
index++;
}
}
/* Set desc and info strings */
option_v2_defs[i].desc = string_is_empty(local_desc) ?
option_defs_us[i].desc : local_desc;
option_v2_defs[i].info = string_is_empty(local_info) ?
option_defs_us[i].info : local_info;
/* v1 options have no concept of categories
* (Note: These are already nullified by
* the preceding calloc(), but we do it
* explicitly here for code clarity) */
option_v2_defs[i].desc_categorized = NULL;
option_v2_defs[i].info_categorized = NULL;
option_v2_defs[i].category_key = NULL;
/* Determine number of values
* (always taken from us english defs) */
for (;;)
{
if (string_is_empty(option_defs_us[i].values[num_values].value))
break;
num_values++;
}
/* Copy values */
for (j = 0; j < num_values; j++)
{
const char *value = option_defs_us[i].values[j].value;
const char *local_label = NULL;
/* Value string is always taken from us english defs */
option_v2_defs[i].values[j].value = value;
/* Try to find corresponding entry in local defs values array */
if (local_values)
{
size_t value_index = 0;
for (;;)
{
const char *local_value = local_values[value_index].value;
if (string_is_empty(local_value))
break;
if (string_is_equal(value, local_value))
{
local_label = local_values[value_index].label;
break;
}
value_index++;
}
}
/* Set value label string */
option_v2_defs[i].values[j].label = string_is_empty(local_label) ?
option_defs_us[i].values[j].label : local_label;
}
}
return options_v2;
}
/**
* core_option_manager_convert_v2_intl:
*
* @options_v2_intl : pointer to a retro_core_options_v2_intl
* struct
*
* Converts a v2 'international' core options struct
* into a regular v2 core options struct. Returned pointer
* must be freed using core_option_manager_free_converted().
*
* Returns: Valid pointer to a new v2 core options struct
* if successful, otherwise NULL.
**/
struct retro_core_options_v2 *core_option_manager_convert_v2_intl(
const struct retro_core_options_v2_intl *options_v2_intl)
{
size_t i;
size_t num_categories = 0;
size_t num_options = 0;
struct retro_core_options_v2 *options_v2_us = NULL;
struct retro_core_options_v2 *options_v2_local = NULL;
struct retro_core_options_v2 *options_v2 = NULL;
struct retro_core_option_v2_category *option_v2_cats = NULL;
struct retro_core_option_v2_definition *option_v2_defs = NULL;
if (!options_v2_intl)
return NULL;
options_v2_us = options_v2_intl->us;
options_v2_local = options_v2_intl->local;
if (!options_v2_us ||
!options_v2_us->definitions)
return NULL;
/* Determine number of categories
* (Note: zero categories are permitted) */
if (options_v2_us->categories)
{
for (;;)
{
if (string_is_empty(options_v2_us->categories[num_categories].key))
break;
num_categories++;
}
}
/* Determine number of options */
for (;;)
{
if (string_is_empty(options_v2_us->definitions[num_options].key))
break;
num_options++;
}
if (num_options < 1)
return NULL;
/* Allocate output retro_core_options_v2 struct */
options_v2 = (struct retro_core_options_v2 *)
malloc(sizeof(*options_v2));
if (!options_v2)
return NULL;
options_v2->categories = NULL;
options_v2->definitions = NULL;
/* Allocate output option_v2_cats array
* > One extra entry required for terminating NULL entry
* > Note that calloc() sets terminating NULL entry */
if (num_categories > 0)
{
option_v2_cats = (struct retro_core_option_v2_category *)
calloc(num_categories + 1, sizeof(*option_v2_cats));
if (!option_v2_cats)
{
core_option_manager_free_converted(options_v2);
return NULL;
}
}
options_v2->categories = option_v2_cats;
/* Allocate output option_v2_defs array
* > One extra entry required for terminating NULL entry
* > Note that calloc() sets terminating NULL entry and
* correctly 'nullifies' each values array */
option_v2_defs = (struct retro_core_option_v2_definition *)
calloc(num_options + 1, sizeof(*option_v2_defs));
if (!option_v2_defs)
{
core_option_manager_free_converted(options_v2);
return NULL;
}
options_v2->definitions = option_v2_defs;
/* Loop through categories...
* (Note: This loop will not execute if
* options_v2_us->categories is NULL) */
for (i = 0; i < num_categories; i++)
{
const char *key = options_v2_us->categories[i].key;
const char *local_desc = NULL;
const char *local_info = NULL;
/* Key is always taken from us english
* categories */
option_v2_cats[i].key = key;
/* Try to find corresponding entry in local
* categories array */
if (options_v2_local &&
options_v2_local->categories)
{
size_t index = 0;
for (;;)
{
const char *local_key = options_v2_local->categories[index].key;
if (string_is_empty(local_key))
break;
if (string_is_equal(key, local_key))
{
local_desc = options_v2_local->categories[index].desc;
local_info = options_v2_local->categories[index].info;
break;
}
index++;
}
}
/* Set desc and info strings */
option_v2_cats[i].desc = string_is_empty(local_desc) ?
options_v2_us->categories[i].desc : local_desc;
option_v2_cats[i].info = string_is_empty(local_info) ?
options_v2_us->categories[i].info : local_info;
}
/* Loop through options... */
for (i = 0; i < num_options; i++)
{
size_t j;
size_t num_values = 0;
const char *key = options_v2_us->definitions[i].key;
const char *local_desc = NULL;
const char *local_desc_categorized = NULL;
const char *local_info = NULL;
const char *local_info_categorized = NULL;
struct retro_core_option_value *local_values = NULL;
/* Key is always taken from us english defs */
option_v2_defs[i].key = key;
/* Default value is always taken from us english defs */
option_v2_defs[i].default_value = options_v2_us->definitions[i].default_value;
/* Try to find corresponding entry in local defs array */
if (options_v2_local &&
options_v2_local->definitions)
{
size_t index = 0;
for (;;)
{
const char *local_key = options_v2_local->definitions[index].key;
if (string_is_empty(local_key))
break;
if (string_is_equal(key, local_key))
{
local_desc = options_v2_local->definitions[index].desc;
local_desc_categorized = options_v2_local->definitions[index].desc_categorized;
local_info = options_v2_local->definitions[index].info;
local_info_categorized = options_v2_local->definitions[index].info_categorized;
local_values = options_v2_local->definitions[index].values;
break;
}
index++;
}
}
/* Set desc and info strings */
option_v2_defs[i].desc = string_is_empty(local_desc) ?
options_v2_us->definitions[i].desc : local_desc;
option_v2_defs[i].desc_categorized = string_is_empty(local_desc_categorized) ?
options_v2_us->definitions[i].desc_categorized : local_desc_categorized;
option_v2_defs[i].info = string_is_empty(local_info) ?
options_v2_us->definitions[i].info : local_info;
option_v2_defs[i].info_categorized = string_is_empty(local_info_categorized) ?
options_v2_us->definitions[i].info_categorized : local_info_categorized;
/* Category key is always taken from us english defs */
option_v2_defs[i].category_key = options_v2_us->definitions[i].category_key;
/* Determine number of values
* (always taken from us english defs) */
for (;;)
{
if (string_is_empty(
options_v2_us->definitions[i].values[num_values].value))
break;
num_values++;
}
/* Copy values */
for (j = 0; j < num_values; j++)
{
const char *value = options_v2_us->definitions[i].values[j].value;
const char *local_label = NULL;
/* Value string is always taken from us english defs */
option_v2_defs[i].values[j].value = value;
/* Try to find corresponding entry in local defs values array */
if (local_values)
{
size_t value_index = 0;
for (;;)
{
const char *local_value = local_values[value_index].value;
if (string_is_empty(local_value))
break;
if (string_is_equal(value, local_value))
{
local_label = local_values[value_index].label;
break;
}
value_index++;
}
}
/* Set value label string */
option_v2_defs[i].values[j].label = string_is_empty(local_label) ?
options_v2_us->definitions[i].values[j].label : local_label;
}
}
return options_v2;
}
/**
* core_option_manager_convert_v2_intl:
*
* @options_v2 : pointer to a retro_core_options_v2
* struct
*
* Frees the pointer returned by any
* core_option_manager_convert_*() function.
**/
void core_option_manager_free_converted(
struct retro_core_options_v2 *options_v2)
{
if (!options_v2)
return;
if (options_v2->categories)
{
free(options_v2->categories);
options_v2->categories = NULL;
}
if (options_v2->definitions)
{
free(options_v2->definitions);
options_v2->definitions = NULL;
}
free(options_v2);
}
/**************************************/
/* Initialisation / De-Initialisation */
/**************************************/
/* Generates a hash key for the specified string */
static uint32_t core_option_manager_hash_string(const char *str)
{
unsigned char c;
uint32_t hash = (uint32_t)0x811c9dc5;
while ((c = (unsigned char)*(str++)) != '\0')
hash = ((hash * (uint32_t)0x01000193) ^ (uint32_t)c);
return (hash ? hash : 1);
}
/* Sanitises a core option value label, handling the case
* where an explicit label is not provided and performing
* conversion of various true/false identifiers to
* ON/OFF strings */
static const char *core_option_manager_parse_value_label(
const char *value, const char *value_label)
{
/* 'value_label' may be NULL */
const char *label = string_is_empty(value_label) ?
value : value_label;
if (string_is_empty(label))
return NULL;
/* Any label starting with a digit (or +/-)
* cannot be a boolean string, and requires
* no further processing */
if (ISDIGIT((unsigned char)*label) ||
(*label == '+') ||
(*label == '-'))
return label;
/* Core devs have a habit of using arbitrary
* strings to label boolean values (i.e. enabled,
* Enabled, on, On, ON, true, True, TRUE, disabled,
* Disabled, off, Off, OFF, false, False, FALSE).
* These should all be converted to standard ON/OFF
* strings
* > Note: We require some duplication here
* (e.g. MENU_ENUM_LABEL_ENABLED *and*
* MENU_ENUM_LABEL_VALUE_ENABLED) in order
* to match both localised and non-localised
* strings. This function is not performance
* critical, so these extra comparisons do
* no harm */
if (string_is_equal_noncase(label, msg_hash_to_str(MENU_ENUM_LABEL_ENABLED)) ||
string_is_equal_noncase(label, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_ENABLED)) ||
string_is_equal_noncase(label, "enable") ||
string_is_equal_noncase(label, "on") ||
string_is_equal_noncase(label, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_ON)) ||
string_is_equal_noncase(label, "true") ||
string_is_equal_noncase(label, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_TRUE)))
label = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_ON);
else if (string_is_equal_noncase(label, msg_hash_to_str(MENU_ENUM_LABEL_DISABLED)) ||
string_is_equal_noncase(label, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_DISABLED)) ||
string_is_equal_noncase(label, "disable") ||
string_is_equal_noncase(label, "off") ||
string_is_equal_noncase(label, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF)) ||
string_is_equal_noncase(label, "false") ||
string_is_equal_noncase(label, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_FALSE)))
label = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF);
return label;
}
/* Parses a single legacy core options interface
* variable, extracting all present core_option
* information */
static bool core_option_manager_parse_variable(
core_option_manager_t *opt, size_t idx,
const struct retro_variable *var,
config_file_t *config_src)
{
size_t i;
union string_list_elem_attr attr;
const char *val_start = NULL;
char *value = NULL;
char *desc_end = NULL;
struct core_option *option = (struct core_option*)&opt->opts[idx];
struct config_entry_list
*entry = NULL;
/* Record option index (required to facilitate
* option map handling) */
option->opt_idx = idx;
/* All options are visible by default */
option->visible = true;
if (!string_is_empty(var->key))
{
option->key = strdup(var->key);
option->key_hash = core_option_manager_hash_string(var->key);
}
if (!string_is_empty(var->value))
value = strdup(var->value);
if (!string_is_empty(value))
desc_end = strstr(value, "; ");
if (!desc_end)
goto error;
*desc_end = '\0';
if (!string_is_empty(value))
option->desc = strdup(value);
val_start = desc_end + 2;
option->vals = string_split(val_start, "|");
if (!option->vals)
goto error;
/* Legacy core option interface has no concept
* of value labels
* > Use actual values for display purposes */
attr.i = 0;
option->val_labels = string_list_new();
if (!option->val_labels)
goto error;
/* > Loop over values and 'extract' labels */
for (i = 0; i < option->vals->size; i++)
{
const char *value = option->vals->elems[i].data;
const char *value_label = core_option_manager_parse_value_label(
value, NULL);
/* Redundant safely check... */
value_label = string_is_empty(value_label) ?
value : value_label;
/* Append value label string */
string_list_append(option->val_labels, value_label, attr);
}
/* Legacy core option interface always uses first
* defined value as the default */
option->default_index = 0;
option->index = 0;
if (config_src)
entry = config_get_entry(config_src, option->key);
else
entry = config_get_entry(opt->conf, option->key);
/* Set current config value */
if (entry && !string_is_empty(entry->value))
{
for (i = 0; i < option->vals->size; i++)
{
if (string_is_equal(option->vals->elems[i].data, entry->value))
{
option->index = i;
break;
}
}
}
/* Legacy core option interface has no concept
* of categories */
option->desc_categorized = NULL;
option->info_categorized = NULL;
option->category_key = NULL;
free(value);
return true;
error:
free(value);
return false;
}
/**
* core_option_manager_new_vars:
*
* @conf_path : Filesystem path to write core option
* config file to
* @src_conf_path : Filesystem path from which to load
* initial config settings.
* @vars : Pointer to core option variable array
* handle
*
* Legacy version of core_option_manager_new().
* Creates and initializes a core manager handle.
*
* Returns: handle to new core manager handle if successful,
* otherwise NULL.
**/
core_option_manager_t *core_option_manager_new_vars(
const char *conf_path, const char *src_conf_path,
const struct retro_variable *vars)
{
const struct retro_variable *var = NULL;
size_t size = 0;
config_file_t *config_src = NULL;
core_option_manager_t *opt = NULL;
if (!vars)
return NULL;
opt = (core_option_manager_t*)malloc(sizeof(*opt));
if (!opt)
return NULL;
opt->conf = NULL;
opt->conf_path[0] = '\0';
/* Legacy core option interface has no concept
* of categories, so leave opt->cats as NULL
* and opt->cats_size as zero */
opt->cats = NULL;
opt->cats_size = 0;
opt->opts = NULL;
opt->size = 0;
opt->option_map = nested_list_init();
opt->updated = false;
if (!opt->option_map)
goto error;
/* Open 'output' config file */
if (!string_is_empty(conf_path))
if (!(opt->conf = config_file_new_from_path_to_string(conf_path)))
if (!(opt->conf = config_file_new_alloc()))
goto error;
strlcpy(opt->conf_path, conf_path, sizeof(opt->conf_path));
/* Load source config file, if required */
if (!string_is_empty(src_conf_path))
config_src = config_file_new_from_path_to_string(src_conf_path);
/* Get number of variables */
for (var = vars; var->key && var->value; var++)
size++;
if (size == 0)
goto error;
/* Create options array */
opt->opts = (struct core_option*)calloc(size, sizeof(*opt->opts));
if (!opt->opts)
goto error;
opt->size = size;
size = 0;
/* Parse each variable */
for (var = vars; var->key && var->value; size++, var++)
{
if (core_option_manager_parse_variable(opt, size, var, config_src))
{
/* If variable is read correctly, add it to
* the map */
char address[256];
address[0] = '\0';
/* Address string is normally:
* <category_key><delim><tag><option_key>
* ...where <tag> is prepended to the option
* key in order to avoid category/option key
* collisions. Legacy options have no categories,
* so we could just set the address to
* <option_key> - but for consistency with
* 'modern' options, we apply the tag regardless */
snprintf(address, sizeof(address),
CORE_OPTION_MANAGER_MAP_TAG "%s", var->key);
if (!nested_list_add_item(opt->option_map,
address, NULL, (const void*)&opt->opts[size]))
goto error;
}
else
goto error;
}
if (config_src)
config_file_free(config_src);
return opt;
error:
if (config_src)
config_file_free(config_src);
core_option_manager_free(opt);
return NULL;
}
/* Parses a single v2 core options interface
* option, extracting all present core_option
* information */
static bool core_option_manager_parse_option(
core_option_manager_t *opt, size_t idx,
const struct retro_core_option_v2_definition *option_def,
config_file_t *config_src)
{
size_t i;
union string_list_elem_attr attr;
struct config_entry_list
*entry = NULL;
size_t num_vals = 0;
struct core_option *option = (struct core_option*)&opt->opts[idx];
const char *key = option_def->key;
const char *category_key = option_def->category_key;
const struct retro_core_option_value
*values = option_def->values;
/* Record option index (required to facilitate
* option map handling) */
option->opt_idx = idx;
/* All options are visible by default */
option->visible = true;
if (!string_is_empty(option_def->desc))
option->desc = strdup(option_def->desc);
if (!string_is_empty(option_def->info))
option->info = strdup(option_def->info);
/* Set category-related parameters
* > Ignore if specified category key does not
* match an entry in the categories array
* > Category key cannot contain a map delimiter
* character */
if (opt->cats &&
!string_is_empty(category_key) &&
!strstr(category_key, CORE_OPTION_MANAGER_MAP_DELIM))
{
for (i = 0; i < opt->cats_size; i++)
{
const char *search_key = opt->cats[i].key;
if (string_is_empty(search_key))
break;
if (string_is_equal(search_key, category_key))
{
option->category_key = strdup(category_key);
if (!string_is_empty(option_def->desc_categorized))
option->desc_categorized = strdup(option_def->desc_categorized);
if (!string_is_empty(option_def->info_categorized))
option->info_categorized = strdup(option_def->info_categorized);
break;
}
}
}
/* Have to set key *after* checking for option
* categories */
if (!string_is_empty(option_def->key))
{
/* If option has a category, option key
* cannot contain a map delimiter character */
if (!string_is_empty(option->category_key) &&
strstr(key, CORE_OPTION_MANAGER_MAP_DELIM))
return false;
option->key = strdup(key);
option->key_hash = core_option_manager_hash_string(key);
}
/* Get number of values */
for (;;)
{
if (string_is_empty(values[num_vals].value))
break;
num_vals++;
}
if (num_vals < 1)
return false;
/* Initialise string lists */
attr.i = 0;
option->vals = string_list_new();
option->val_labels = string_list_new();
if (!option->vals || !option->val_labels)
return false;
/* Initialise default value */
option->default_index = 0;
option->index = 0;
/* Extract value/label pairs */
for (i = 0; i < num_vals; i++)
{
const char *value = values[i].value;
const char *value_label = values[i].label;
/* Append value string
* > We know that 'value' is always valid */
string_list_append(option->vals, value, attr);
/* Value label requires additional processing */
value_label = core_option_manager_parse_value_label(
value, value_label);
/* > Redundant safely check... */
value_label = string_is_empty(value_label) ?
value : value_label;
/* Append value label string */
string_list_append(option->val_labels, value_label, attr);
/* Check whether this value is the default setting */
if (!string_is_empty(option_def->default_value))
{
if (string_is_equal(option_def->default_value, value))
{
option->default_index = i;
option->index = i;
}
}
}
if (config_src)
entry = config_get_entry(config_src, option->key);
else
entry = config_get_entry(opt->conf, option->key);
/* Set current config value */
if (entry && !string_is_empty(entry->value))
{
for (i = 0; i < option->vals->size; i++)
{
if (string_is_equal(option->vals->elems[i].data, entry->value))
{
option->index = i;
break;
}
}
}
return true;
}
/**
* core_option_manager_new:
*
* @conf_path : Filesystem path to write core option
* config file to
* @src_conf_path : Filesystem path from which to load
* initial config settings.
* @options_v2 : Pointer to retro_core_options_v2 struct
* @categorized : Flag specifying whether core option
* category information should be read
* from @options_v2
*
* Creates and initializes a core manager handle. Parses
* information from a retro_core_options_v2 struct.
* If @categorized is false, all option category
* assignments will be ignored.
*
* Returns: handle to new core manager handle if successful,
* otherwise NULL.
**/
core_option_manager_t *core_option_manager_new(
const char *conf_path, const char *src_conf_path,
const struct retro_core_options_v2 *options_v2,
bool categorized)
{
const struct retro_core_option_v2_category *option_cat = NULL;
const struct retro_core_option_v2_definition *option_def = NULL;
struct retro_core_option_v2_category *option_cats = NULL;
struct retro_core_option_v2_definition *option_defs = NULL;
size_t cats_size = 0;
size_t size = 0;
config_file_t *config_src = NULL;
core_option_manager_t *opt = NULL;
if (!options_v2 ||
!options_v2->definitions)
return NULL;
option_cats = options_v2->categories;
option_defs = options_v2->definitions;
opt = (core_option_manager_t*)malloc(sizeof(*opt));
if (!opt)
return NULL;
opt->conf = NULL;
opt->conf_path[0] = '\0';
opt->cats = NULL;
opt->cats_size = 0;
opt->opts = NULL;
opt->size = 0;
opt->option_map = nested_list_init();
opt->updated = false;
if (!opt->option_map)
goto error;
/* Open 'output' config file */
if (!string_is_empty(conf_path))
if (!(opt->conf = config_file_new_from_path_to_string(conf_path)))
if (!(opt->conf = config_file_new_alloc()))
goto error;
strlcpy(opt->conf_path, conf_path, sizeof(opt->conf_path));
/* Load source config file, if required */
if (!string_is_empty(src_conf_path))
config_src = config_file_new_from_path_to_string(src_conf_path);
/* Get number of categories, if required
* > Note: 'option_cat->info == NULL' is valid */
if (categorized && option_cats)
{
for (option_cat = option_cats;
!string_is_empty(option_cat->key) &&
!string_is_empty(option_cat->desc);
option_cat++)
cats_size++;
}
/* Get number of options
* > Note: 'option_def->info == NULL' is valid */
for (option_def = option_defs;
option_def->key && option_def->desc && option_def->values[0].value;
option_def++)
size++;
if (size == 0)
goto error;
/* Create categories array */
if (cats_size > 0)
{
opt->cats = (struct core_catagory*)calloc(size, sizeof(*opt->cats));
if (!opt->cats)
goto error;
opt->cats_size = cats_size;
cats_size = 0;
/* Parse each category
* > Note: 'option_cat->info == NULL' is valid */
for (option_cat = option_cats;
!string_is_empty(option_cat->key) &&
!string_is_empty(option_cat->desc);
cats_size++, option_cat++)
{
opt->cats[cats_size].key = strdup(option_cat->key);
opt->cats[cats_size].key_hash = core_option_manager_hash_string(option_cat->key);
opt->cats[cats_size].desc = strdup(option_cat->desc);
if (!string_is_empty(option_cat->info))
opt->cats[cats_size].info = strdup(option_cat->info);
}
}
/* Create options array */
opt->opts = (struct core_option*)calloc(size, sizeof(*opt->opts));
if (!opt->opts)
goto error;
opt->size = size;
size = 0;
/* Parse each option
* > Note: 'option_def->info == NULL' is valid */
for (option_def = option_defs;
option_def->key && option_def->desc && option_def->values[0].value;
size++, option_def++)
{
if (core_option_manager_parse_option(opt, size, option_def, config_src))
{
/* If option is read correctly, add it to
* the map */
const char *category_key = opt->opts[size].category_key;
char address[256];
address[0] = '\0';
/* Address string is nominally:
* <category_key><delim><tag><option_key>
* ...where <tag> is prepended to the option
* key in order to avoid category/option key
* collisions */
if (string_is_empty(category_key))
snprintf(address, sizeof(address),
CORE_OPTION_MANAGER_MAP_TAG "%s", option_def->key);
else
snprintf(address, sizeof(address),
"%s" CORE_OPTION_MANAGER_MAP_DELIM CORE_OPTION_MANAGER_MAP_TAG "%s",
category_key, option_def->key);
if (!nested_list_add_item(opt->option_map,
address, CORE_OPTION_MANAGER_MAP_DELIM,
(const void*)&opt->opts[size]))
goto error;
}
else
goto error;
}
if (config_src)
config_file_free(config_src);
return opt;
error:
if (config_src)
config_file_free(config_src);
core_option_manager_free(opt);
return NULL;
}
/**
* core_option_manager_free:
*
* @opt : options manager handle
*
* Frees specified core options manager handle.
**/
void core_option_manager_free(core_option_manager_t *opt)
{
size_t i;
if (!opt)
return;
for (i = 0; i < opt->cats_size; i++)
{
if (opt->cats[i].key)
free(opt->cats[i].key);
if (opt->cats[i].desc)
free(opt->cats[i].desc);
if (opt->cats[i].info)
free(opt->cats[i].info);
opt->cats[i].key = NULL;
opt->cats[i].desc = NULL;
opt->cats[i].info = NULL;
}
for (i = 0; i < opt->size; i++)
{
if (opt->opts[i].desc)
free(opt->opts[i].desc);
if (opt->opts[i].desc_categorized)
free(opt->opts[i].desc_categorized);
if (opt->opts[i].info)
free(opt->opts[i].info);
if (opt->opts[i].info_categorized)
free(opt->opts[i].info_categorized);
if (opt->opts[i].key)
free(opt->opts[i].key);
if (opt->opts[i].category_key)
free(opt->opts[i].category_key);
if (opt->opts[i].vals)
string_list_free(opt->opts[i].vals);
if (opt->opts[i].val_labels)
string_list_free(opt->opts[i].val_labels);
opt->opts[i].desc = NULL;
opt->opts[i].desc_categorized = NULL;
opt->opts[i].info = NULL;
opt->opts[i].info_categorized = NULL;
opt->opts[i].key = NULL;
opt->opts[i].category_key = NULL;
opt->opts[i].vals = NULL;
}
if (opt->option_map)
nested_list_free(opt->option_map);
if (opt->conf)
config_file_free(opt->conf);
free(opt->cats);
free(opt->opts);
free(opt);
}
/********************/
/* Category Getters */
/********************/
/**
* core_option_manager_get_category_desc:
*
* @opt : options manager handle
* @key : core option category id string
*
* Fetches the 'description' text of the core option
* category identified by @key (used as the
* category label in the menu).
*
* Returns: description string (menu label) of the
* specified option category if successful,
* otherwise NULL.
**/
const char *core_option_manager_get_category_desc(core_option_manager_t *opt,
const char *key)
{
uint32_t key_hash;
size_t i;
if (!opt ||
string_is_empty(key))
return NULL;
key_hash = core_option_manager_hash_string(key);
for (i = 0; i < opt->cats_size; i++)
{
struct core_catagory *catagory = &opt->cats[i];
if ((key_hash == catagory->key_hash) &&
!string_is_empty(catagory->key) &&
string_is_equal(key, catagory->key))
{
return catagory->desc;
}
}
return NULL;
}
/**
* core_option_manager_get_category_info:
*
* @opt : options manager handle
* @key : core option category id string
*
* Fetches the 'info' text of the core option
* category identified by @key (used as the category
* sublabel in the menu).
*
* Returns: information string (menu sublabel) of
* the specified option category if successful,
* otherwise NULL.
**/
const char *core_option_manager_get_category_info(core_option_manager_t *opt,
const char *key)
{
uint32_t key_hash;
size_t i;
if (!opt ||
string_is_empty(key))
return NULL;
key_hash = core_option_manager_hash_string(key);
for (i = 0; i < opt->cats_size; i++)
{
struct core_catagory *catagory = &opt->cats[i];
if ((key_hash == catagory->key_hash) &&
!string_is_empty(catagory->key) &&
string_is_equal(key, catagory->key))
{
return catagory->info;
}
}
return NULL;
}
/**
* core_option_manager_get_category_visible:
*
* @opt : options manager handle
* @key : core option category id string
*
* Queries whether the core option category
* identified by @key should be displayed in
* the frontend menu. (A category is deemed to
* be visible if at least one of the options
* in the category is visible)
*
* Returns: true if option category should be
* displayed by the frontend, otherwise false.
**/
bool core_option_manager_get_category_visible(core_option_manager_t *opt,
const char *key)
{
nested_list_item_t *category_item = NULL;
nested_list_t *option_list = NULL;
nested_list_item_t *option_item = NULL;
const struct core_option *option = NULL;
size_t i;
if (!opt ||
string_is_empty(key))
return false;
/* Fetch category item from map */
category_item = nested_list_get_item(opt->option_map,
key, NULL);
if (!category_item)
return false;
/* Get child options of specified category */
option_list = nested_list_item_get_children(category_item);
if (!option_list)
return false;
/* Loop over child options */
for (i = 0; i < nested_list_get_size(option_list); i++)
{
option_item = nested_list_get_item_idx(option_list, i);
option = (const struct core_option *)
nested_list_item_get_value(option_item);
/* Check if current option is visible */
if (option && option->visible)
return true;
}
return false;
}
/******************/
/* Option Getters */
/******************/
/**
* core_option_manager_get_idx:
*
* @opt : options manager handle
* @key : core option key string (variable to query
* in RETRO_ENVIRONMENT_GET_VARIABLE)
* @idx : index of core option corresponding
* to @key
*
* Fetches the index of the core option identified
* by the specified @key.
*
* Returns: true if option matching the specified
* key was found, otherwise false.
**/
bool core_option_manager_get_idx(core_option_manager_t *opt,
const char *key, size_t *idx)
{
uint32_t key_hash;
size_t i;
if (!opt ||
string_is_empty(key) ||
!idx)
return false;
key_hash = core_option_manager_hash_string(key);
for (i = 0; i < opt->size; i++)
{
struct core_option *option = &opt->opts[i];
if ((key_hash == option->key_hash) &&
!string_is_empty(option->key) &&
string_is_equal(key, option->key))
{
*idx = i;
return true;
}
}
return false;
}
/**
* core_option_manager_get_desc:
*
* @opt : options manager handle
* @idx : core option index
* @categorized : flag specifying whether to
* fetch the categorised description
* or the legacy fallback
*
* Fetches the 'description' of the core option at
* index @idx (used as the option label in the menu).
* If menu has option category support, @categorized
* should be true. (At present, only the Qt interface
* requires @categorized to be false)
*
* Returns: description string (menu label) of the
* specified option if successful, otherwise NULL.
**/
const char *core_option_manager_get_desc(core_option_manager_t *opt,
size_t idx, bool categorized)
{
const char *desc = NULL;
if (!opt ||
(idx >= opt->size))
return NULL;
/* Try categorised description first,
* if requested */
if (categorized)
desc = opt->opts[idx].desc_categorized;
/* Fall back to legacy description, if
* required */
if (string_is_empty(desc))
desc = opt->opts[idx].desc;
return desc;
}
/**
* core_option_manager_get_info:
*
* @opt : options manager handle
* @idx : core option index
* @categorized : flag specifying whether to
* fetch the categorised information
* or the legacy fallback
*
* Fetches the 'info' text of the core option at
* index @idx (used as the option sublabel in the
* menu). If menu has option category support,
* @categorized should be true. (At present, only
* the Qt interface requires @categorized to be false)
*
* Returns: information string (menu sublabel) of the
* specified option if successful, otherwise NULL.
**/
const char *core_option_manager_get_info(core_option_manager_t *opt,
size_t idx, bool categorized)
{
const char *info = NULL;
if (!opt ||
(idx >= opt->size))
return NULL;
/* Try categorised information first,
* if requested */
if (categorized)
info = opt->opts[idx].info_categorized;
/* Fall back to legacy information, if
* required */
if (string_is_empty(info))
info = opt->opts[idx].info;
return info;
}
/**
* core_option_manager_get_val:
*
* @opt : options manager handle
* @idx : core option index
*
* Fetches the string representation of the current
* value of the core option at index @idx.
*
* Returns: core option value string if successful,
* otherwise NULL.
**/
const char *core_option_manager_get_val(core_option_manager_t *opt,
size_t idx)
{
struct core_option *option = NULL;
if (!opt ||
(idx >= opt->size))
return NULL;
option = (struct core_option*)&opt->opts[idx];
return option->vals->elems[option->index].data;
}
/**
* core_option_manager_get_val_label:
*
* @opt : options manager handle
* @idx : core option index
*
* Fetches the 'label' text (used for display purposes
* in the menu) for the current value of the core
* option at index @idx.
*
* Returns: core option value label string if
* successful, otherwise NULL.
**/
const char *core_option_manager_get_val_label(core_option_manager_t *opt,
size_t idx)
{
struct core_option *option = NULL;
if (!opt ||
(idx >= opt->size))
return NULL;
option = (struct core_option*)&opt->opts[idx];
return option->val_labels->elems[option->index].data;
}
/**
* core_option_manager_get_visible:
*
* @opt : options manager handle
* @idx : core option index
*
* Queries whether the core option at index @idx
* should be displayed in the frontend menu.
*
* Returns: true if option should be displayed by
* the frontend, otherwise false.
**/
bool core_option_manager_get_visible(core_option_manager_t *opt,
size_t idx)
{
if (!opt ||
(idx >= opt->size))
return false;
return opt->opts[idx].visible;
}
/******************/
/* Option Setters */
/******************/
/**
* core_option_manager_set_val:
*
* @opt : options manager handle
* @idx : core option index
* @val_idx : index of the value to set
* @refresh_menu : flag specifying whether menu
* should be refreshed if changes
* to option visibility are detected
*
* Sets the core option at index @idx to the
* option value corresponding to @val_idx.
* After setting the option value, a request
* will be made for the core to update the
* in-menu visibility of all options; if
* visibility changes are detected and
* @refresh_menu is true, the menu will be
* redrawn.
**/
void core_option_manager_set_val(core_option_manager_t *opt,
size_t idx, size_t val_idx, bool refresh_menu)
{
struct core_option *option = NULL;
if (!opt ||
(idx >= opt->size))
return;
option = (struct core_option*)&opt->opts[idx];
option->index = val_idx % option->vals->size;
opt->updated = true;
#ifdef HAVE_CHEEVOS
rcheevos_validate_config_settings();
#endif
#ifdef HAVE_MENU
/* Refresh menu (if required) if core option
* visibility has changed as a result of modifying
* the current option value */
if (rarch_ctl(RARCH_CTL_CORE_OPTION_UPDATE_DISPLAY, NULL) &&
refresh_menu)
{
bool refresh = false;
menu_entries_ctl(MENU_ENTRIES_CTL_SET_REFRESH, &refresh);
menu_driver_ctl(RARCH_MENU_CTL_SET_PREVENT_POPULATE, NULL);
}
#endif
}
/**
* core_option_manager_adjust_val:
*
* @opt : options manager handle
* @idx : core option index
* @adjustment : offset to apply from current
* value index
* @refresh_menu : flag specifying whether menu
* should be refreshed if changes
* to option visibility are detected
*
* Modifies the value of the core option at
* index @idx by incrementing the current option
* value index by @adjustment.
* After setting the option value, a request
* will be made for the core to update the
* in-menu visibility of all options; if
* visibility changes are detected and
* @refresh_menu is true, the menu will be
* redrawn.
**/
void core_option_manager_adjust_val(core_option_manager_t* opt,
size_t idx, int adjustment, bool refresh_menu)
{
struct core_option* option = NULL;
if (!opt ||
(idx >= opt->size))
return;
option = (struct core_option*)&opt->opts[idx];
option->index = (option->index + option->vals->size + adjustment) % option->vals->size;
opt->updated = true;
#ifdef HAVE_CHEEVOS
rcheevos_validate_config_settings();
#endif
#ifdef HAVE_MENU
/* Refresh menu (if required) if core option
* visibility has changed as a result of modifying
* the current option value */
if (rarch_ctl(RARCH_CTL_CORE_OPTION_UPDATE_DISPLAY, NULL) &&
refresh_menu)
{
bool refresh = false;
menu_entries_ctl(MENU_ENTRIES_CTL_SET_REFRESH, &refresh);
menu_driver_ctl(RARCH_MENU_CTL_SET_PREVENT_POPULATE, NULL);
}
#endif
}
/**
* core_option_manager_set_default:
*
* @opt : options manager handle
* @idx : core option index
* @refresh_menu : flag specifying whether menu
* should be refreshed if changes
* to option visibility are detected
*
* Resets the core option at index @idx to
* its default value.
* After setting the option value, a request
* will be made for the core to update the
* in-menu visibility of all options; if
* visibility changes are detected and
* @refresh_menu is true, the menu will be
* redrawn.
**/
void core_option_manager_set_default(core_option_manager_t *opt,
size_t idx, bool refresh_menu)
{
if (!opt ||
(idx >= opt->size))
return;
opt->opts[idx].index = opt->opts[idx].default_index;
opt->updated = true;
#ifdef HAVE_CHEEVOS
rcheevos_validate_config_settings();
#endif
#ifdef HAVE_MENU
/* Refresh menu (if required) if core option
* visibility has changed as a result of modifying
* the current option value */
if (rarch_ctl(RARCH_CTL_CORE_OPTION_UPDATE_DISPLAY, NULL) &&
refresh_menu)
{
bool refresh = false;
menu_entries_ctl(MENU_ENTRIES_CTL_SET_REFRESH, &refresh);
menu_driver_ctl(RARCH_MENU_CTL_SET_PREVENT_POPULATE, NULL);
}
#endif
}
/**
* core_option_manager_set_visible:
*
* @opt : options manager handle
* @key : core option key string (variable to query
* in RETRO_ENVIRONMENT_GET_VARIABLE)
* @visible : flag specifying whether option should
* be shown in the menu
*
* Sets the in-menu visibility of the core option
* identified by the specified @key.
**/
void core_option_manager_set_visible(core_option_manager_t *opt,
const char *key, bool visible)
{
uint32_t key_hash;
size_t i;
if (!opt || string_is_empty(key))
return;
key_hash = core_option_manager_hash_string(key);
for (i = 0; i < opt->size; i++)
{
struct core_option *option = &opt->opts[i];
if ((key_hash == option->key_hash) &&
!string_is_empty(option->key) &&
string_is_equal(key, option->key))
{
option->visible = visible;
return;
}
}
}
/**********************/
/* Configuration File */
/**********************/
/**
* core_option_manager_flush:
*
* @opt : options manager handle
* @conf : configuration file handle
*
* Writes all core option key-pair values from the
* specified core option manager handle to the
* specified configuration file struct.
**/
void core_option_manager_flush(core_option_manager_t *opt,
config_file_t *conf)
{
size_t i;
for (i = 0; i < opt->size; i++)
{
struct core_option *option = (struct core_option*)&opt->opts[i];
if (option)
config_set_string(conf, option->key,
opt->opts[i].vals->elems[opt->opts[i].index].data);
}
}
Reference in New Issue View Git Blame Copy Permalink