void config_setting_copy_simple(config_setting_t *parent, const config_setting_t *src)
{
if (config_setting_is_aggregate(src)) {
config_setting_copy_aggregate(parent, src);
}
else {
config_setting_t *set;
if( config_setting_get_member(parent, config_setting_name(src)) != NULL )
return;
if ((set = config_setting_add(parent, config_setting_name(src), config_setting_type(src))) == NULL)
return;
if (CONFIG_TYPE_INT == config_setting_type(src)) {
config_setting_set_int(set, config_setting_get_int(src));
config_setting_set_format(set, src->format);
} else if (CONFIG_TYPE_INT64 == config_setting_type(src)) {
config_setting_set_int64(set, config_setting_get_int64(src));
config_setting_set_format(set, src->format);
} else if (CONFIG_TYPE_FLOAT == config_setting_type(src)) {
config_setting_set_float(set, config_setting_get_float(src));
} else if (CONFIG_TYPE_STRING == config_setting_type(src)) {
config_setting_set_string(set, config_setting_get_string(src));
} else if (CONFIG_TYPE_BOOL == config_setting_type(src)) {
config_setting_set_bool(set, config_setting_get_bool(src));
}
}
}
config_setting_t *config_setting_set_bool_elem(config_setting_t *vector,
int idx, int value)
{
config_setting_t *element = NULL;
if((vector->type != CONFIG_TYPE_ARRAY) && (vector->type != CONFIG_TYPE_LIST))
return(NULL);
if(idx < 0)
{
if(! __config_vector_checktype(vector, CONFIG_TYPE_BOOL))
return(NULL);
element = config_setting_create(vector, NULL, CONFIG_TYPE_BOOL);
}
else
element = config_setting_get_elem(vector, idx);
if(! element)
return(NULL);
if(! config_setting_set_bool(element, value))
return(NULL);
return(element);
}
void MainDialog::configSetBool(const char* key, bool val) {
config_setting_t* setting = config_lookup(&config_, key);
if(!setting) { // setting not found
// add a new setting for it
config_setting_t* root = config_root_setting(&config_);
setting = config_setting_add(root, key, CONFIG_TYPE_BOOL);
}
config_setting_set_bool(setting, val);
}
config_setting_t *cfgSetBool(config_setting_t *parent, const TCHAR *name, int value)
{
config_setting_t *setting;
char uName[CONFIG_UTF8_MAXSTRING];
UTF8_Encode(name, uName, CONFIG_UTF8_MAXSTRING);
setting = config_setting_add(parent, uName, CONFIG_TYPE_BOOL);
config_setting_set_bool(setting, value);
return setting;
}
//-----------------------------------------------------------------------------
int t_display_save_configuration (config_setting_t *setting, T_Display *d)
{
config_setting_t *s, *sp = NULL ;
s = config_setting_add(setting, NULL, CONFIG_TYPE_GROUP) ;
sp = config_setting_add(s, "type", CONFIG_TYPE_INT) ;
config_setting_set_int(sp, d->type);
sp = config_setting_add(s, "width", CONFIG_TYPE_INT) ;
config_setting_set_int(sp, d->canvas->allocation.width);
sp = config_setting_add(s, "height", CONFIG_TYPE_INT) ;
config_setting_set_int(sp, d->canvas->allocation.height);
sp = config_setting_add(s, "position_x", CONFIG_TYPE_INT) ;
config_setting_set_int(sp, d->canvas->allocation.x);
sp = config_setting_add(s, "position_y", CONFIG_TYPE_INT) ;
config_setting_set_int(sp, d->canvas->allocation.y);
sp = config_setting_add(s, "time_range", CONFIG_TYPE_INT) ;
config_setting_set_int(sp, d->time_range);
sp = config_setting_add(s, "last_time", CONFIG_TYPE_INT) ;
config_setting_set_int(sp, d->last_time);
sp = config_setting_add(s, "time_step", CONFIG_TYPE_INT) ;
config_setting_set_int(sp, d->time_step);
sp = config_setting_add(s, "temp_max", CONFIG_TYPE_INT) ;
config_setting_set_int(sp, d->temp_max);
sp = config_setting_add(s, "temp_min", CONFIG_TYPE_INT) ;
config_setting_set_int(sp, d->temp_min);
sp = config_setting_add(s, "temp_step", CONFIG_TYPE_INT) ;
config_setting_set_int(sp, d->temp_step);
sp = config_setting_add(s, "font_size", CONFIG_TYPE_INT) ;
config_setting_set_int(sp, d->font_size);
sp = config_setting_add(s, "show_legend", CONFIG_TYPE_BOOL) ;
config_setting_set_bool(sp, d->show_legend);
// sp = config_setting_add(s, "n_plots", CONFIG_TYPE_INT) ;
// config_setting_set_int(sp, g_list_length(d->plots));
sp = config_setting_add(s, "Plots", CONFIG_TYPE_LIST) ;
GList *tmp = d->plots ;
while (tmp != NULL) {
t_plot_save_configuration(sp, (T_Plot*)tmp->data) ;
tmp = g_list_next(tmp) ;
} ;
return 0 ;
} ;
gboolean
get_verbose ()
{
gboolean verbose;
gchar *file;
config_t config;
file = g_strconcat (g_getenv ("HOME"),
"/.config/gjackctl/gjackctl.conf",
NULL);
config_init (&config);
config_read_file (&config, file);
if (config_lookup_bool (&config, "gjackctl.server.verbose", &verbose) == CONFIG_FALSE)
{
config_setting_t *group;
config_setting_t *setting;
g_print ("Verbose config option not available\n");
g_print ("Creating config setting now...\n");
group = config_lookup (&config, "gjackctl.server");
setting = config_setting_add (group, "verbose", CONFIG_TYPE_BOOL);
config_setting_set_bool (setting, FALSE);
config_write_file (&config, file);
}
if (verbose == FALSE)
{
config_destroy (&config);
return FALSE;
}
else
{
config_destroy (&config);
return TRUE;
}
}
/*********************
return RET_NOK on error
*********************/
ret_code_t entry_copy_config(config_setting_t * source, config_setting_t * dest)
{
config_setting_t * new_source;
config_setting_t * new_dest;
int index = -1;
int int_value;
long long long_value;
double double_value;
const char * string;
while((new_source=config_setting_get_elem(source,index+1))!= NULL ) {
index++;
if(config_setting_is_group(new_source)) {
if(!entry_copy_aggregate(new_source,dest,CONFIG_TYPE_GROUP)) {
return RET_NOK;
}
}
else if(config_setting_is_array(new_source)) {
if(!entry_copy_aggregate(new_source,dest,CONFIG_TYPE_ARRAY)) {
return RET_NOK;
}
}
else if(config_setting_is_list(new_source)) {
if(!entry_copy_aggregate(new_source,dest,CONFIG_TYPE_LIST)) {
return RET_NOK;
}
}
else {
switch(config_setting_type(new_source)) {
case CONFIG_TYPE_INT:
int_value = config_setting_get_int(new_source);
new_dest = config_setting_add (dest, config_setting_name(new_source),CONFIG_TYPE_INT);
config_setting_set_int(new_dest,int_value);
continue;
case CONFIG_TYPE_INT64:
long_value = config_setting_get_int64(new_source);
new_dest = config_setting_add (dest, config_setting_name(new_source),CONFIG_TYPE_INT64);
config_setting_set_int64(new_dest,long_value);
continue;
case CONFIG_TYPE_FLOAT:
double_value = config_setting_get_float(new_source);
new_dest = config_setting_add (dest, config_setting_name(new_source),CONFIG_TYPE_FLOAT);
config_setting_set_float(new_dest,double_value);
continue;
case CONFIG_TYPE_BOOL:
int_value = config_setting_get_bool(new_source);
new_dest = config_setting_add (dest, config_setting_name(new_source),CONFIG_TYPE_BOOL);
config_setting_set_bool(new_dest,int_value);
continue;
case CONFIG_TYPE_STRING:
string = config_setting_get_string(new_source);
new_dest = config_setting_add (dest, config_setting_name(new_source),CONFIG_TYPE_STRING);
config_setting_set_string(new_dest,string);
continue;
default:
return RET_NOK;
}
}
}
return RET_OK;
}
// load the default configuration in cfg
static void set_default_config(config_t * cfg) {
static const unsigned AACCESSES = 4 * 1024 * 1024;
static const unsigned BEGIN = BEGIN_INIT;
static const char SPAWN[] = "linear";
static const long long END = END_INIT;
static const float FREQUENCY = 1;
static const bool LOGGING = false;
static const char LOGFILE[] = "adhd_log";
static const char PATTERN[] = "random";
static const unsigned PROCESSES = 1;
static const unsigned REPETITIONS = 50;
static const long long STEP = STEP_INIT;
static const char SCALING[] = "linear";
static const bool SILENT = false;
static const unsigned THREADS = 1;
static const long long STREAM_STEP = 10 * (1 << 20);
static const long long STREAM_END = 100 * (1 << 20);
static const long long FLOPS_STEP = 10 * (1 << 10);
static const long long FLOPS_END = 1 * (1 << 20);
static const long long FLOPS_CALCULATIONS = 1000 * 1000 * 1000;
config_setting_t *setting;
config_setting_t *root;
root = config_root_setting(cfg);
// generic group
{
config_setting_t *generic =
config_setting_add(root, FLD_GENERIC_GROUP, CONFIG_TYPE_GROUP);
// array of names of enabled programs (uses corresponding group names for
// the sake of simplicity)
{
config_setting_t *programs =
config_setting_add(generic, FLD_PROGRAMS_GROUP, CONFIG_TYPE_ARRAY);
static const char *names[] = {
FLD_WALKARRAY_GROUP,
FLD_STREAMARRAY_GROUP,
FLD_FLOPSARRAY_GROUP,
NULL // mark end of list
};
for (size_t i = 0; names[i]; ++i) {
setting = config_setting_add(programs, NULL, CONFIG_TYPE_STRING);
config_setting_set_string(setting, names[i]);
}
}
// CPU frequency to calculate cycle estimate
// TODO: use actual cycle counter in the CPU
// (this is a feature with a design impact, as SMP complicates matters ... :))
setting = config_setting_add(generic, FLD_GENERIC_GPU_FREQUENCY, CONFIG_TYPE_FLOAT);
config_setting_set_float(setting, FREQUENCY);
// logging enabled?
setting = config_setting_add(generic, FLD_GENERIC_LOGGING, CONFIG_TYPE_BOOL);
config_setting_set_bool(setting, LOGGING);
// base filename to log process timings to
setting = config_setting_add(generic, FLD_GENERIC_LOGFILE, CONFIG_TYPE_STRING);
config_setting_set_string(setting, LOGFILE);
// process spawn method
setting = config_setting_add(generic, FLD_GENERIC_SPAWN, CONFIG_TYPE_STRING);
config_setting_set_string(setting, SPAWN);
// number of processes to run: begin
// TODO: just like arrays we could have a linear or exponential increment
setting = config_setting_add(generic, FLD_GENERIC_PROCESSES_BEGIN, CONFIG_TYPE_INT64);
config_setting_set_int64(setting, PROCESSES);
// number of processes to run: end
setting = config_setting_add(generic, FLD_GENERIC_PROCESSES_END, CONFIG_TYPE_INT64);
config_setting_set_int64(setting, PROCESSES);
// number of threads per process to run: begin
// TODO: just like arrays we could have a linear or exponential increment
setting = config_setting_add(generic, FLD_GENERIC_THREADS_BEGIN, CONFIG_TYPE_INT64);
config_setting_set_int64(setting, THREADS);
// number of threads per process to run: end
setting = config_setting_add(generic, FLD_GENERIC_THREADS_END, CONFIG_TYPE_INT64);
config_setting_set_int64(setting, THREADS);
// silent mode
setting = config_setting_add(generic, FLD_GENERIC_SILENT, CONFIG_TYPE_BOOL);
config_setting_set_bool(setting, SILENT);
}
// walking array group
{
config_setting_t *array =
config_setting_add(root, FLD_WALKARRAY_GROUP, CONFIG_TYPE_GROUP);
// array accesses
setting = config_setting_add(array, FLD_WALKARRAY_ACCESSES, CONFIG_TYPE_INT64);
config_setting_set_int64(setting, AACCESSES);
// repetitions of a single test, to be able to calculate an average
// and a standard deviation, indicating run precision
setting = config_setting_add(array, FLD_WALKARRAY_REPEAT, CONFIG_TYPE_INT64);
config_setting_set_int64(setting, REPETITIONS);
// initial array size
setting = config_setting_add(array, FLD_WALKARRAY_BEGINLENGTH, CONFIG_TYPE_INT64);
config_setting_set_int64(setting, BEGIN);
// maximal array size
setting = config_setting_add(array, FLD_WALKARRAY_ENDLENGTH, CONFIG_TYPE_INT64);
config_setting_set_int64(setting, END);
// increment factor
setting = config_setting_add(array, FLD_WALKARRAY_INCREMENT, CONFIG_TYPE_INT64);
config_setting_set_int64(setting, STEP);
// increment type
// (linear adds the increment, exponential multiplies the previous length)
setting = config_setting_add(array, FLD_WALKARRAY_SCALING, CONFIG_TYPE_STRING);
config_setting_set_string(setting, SCALING);
// walking pattern
// (sequentially increasing/decreasing or random)
setting = config_setting_add(array, FLD_WALKARRAY_PATTERN, CONFIG_TYPE_STRING);
config_setting_set_string(setting, PATTERN);
}
// streaming array group
{
config_setting_t *array =
config_setting_add(root, FLD_STREAMARRAY_GROUP, CONFIG_TYPE_GROUP);
// initial array size
setting = config_setting_add(array, FLD_STREAMARRAY_BEGINLENGTH, CONFIG_TYPE_INT64);
config_setting_set_int64(setting, BEGIN);
// maximal array size
setting = config_setting_add(array, FLD_STREAMARRAY_ENDLENGTH, CONFIG_TYPE_INT64);
config_setting_set_int64(setting, STREAM_END);
// increment factor
setting = config_setting_add(array, FLD_STREAMARRAY_INCREMENT, CONFIG_TYPE_INT64);
config_setting_set_int64(setting, STREAM_STEP);
// increment type
// (linear adds the increment, exponential multiplies the previous length)
setting = config_setting_add(array, FLD_STREAMARRAY_SCALING, CONFIG_TYPE_STRING);
config_setting_set_string(setting, SCALING);
}
// flops array group
{
config_setting_t *array =
config_setting_add(root, FLD_FLOPSARRAY_GROUP, CONFIG_TYPE_GROUP);
// initial array size
setting = config_setting_add(array, FLD_FLOPSARRAY_BEGINLENGTH, CONFIG_TYPE_INT64);
config_setting_set_int64(setting, BEGIN);
// maximal array size
setting = config_setting_add(array, FLD_FLOPSARRAY_ENDLENGTH, CONFIG_TYPE_INT64);
config_setting_set_int64(setting, FLOPS_END);
// increment factor
setting = config_setting_add(array, FLD_FLOPSARRAY_INCREMENT, CONFIG_TYPE_INT64);
config_setting_set_int64(setting, FLOPS_STEP);
// increment type
// (linear adds the increment, exponential multiplies the previous length)
setting = config_setting_add(array, FLD_FLOPSARRAY_SCALING, CONFIG_TYPE_STRING);
config_setting_set_string(setting, SCALING);
// number of calculations to perform
setting = config_setting_add(array, FLD_FLOPSARRAY_CALCULATIONS, CONFIG_TYPE_INT64);
config_setting_set_int64(setting, FLOPS_CALCULATIONS);
}
}
void settings_add_to_config(config_t *config)
{
int i;
char value[256];
config_setting_t *root;
config_setting_t *ps2;
config_setting_t *group;
config_setting_t *setting;
if (config == NULL)
{
return;
}
root = config_root_setting(config);
ps2 = config_setting_add(root,"PS2", CONFIG_TYPE_GROUP);
{
group = config_setting_add(ps2,"Home",CONFIG_TYPE_GROUP);
{
setting = config_setting_add(group,"Partition",CONFIG_TYPE_STRING);
config_setting_set_string(setting,settings.home.partition);
setting = config_setting_add(group,"Directory",CONFIG_TYPE_STRING);
config_setting_set_string(setting,settings.home.directory);
}
group = config_setting_add(ps2,"Display", CONFIG_TYPE_GROUP);
{
setting = config_setting_add(group,"OffsetX",CONFIG_TYPE_STRING);
cfg_int_to_string(value,settings.display.x);
config_setting_set_string(setting,value);
setting = config_setting_add(group,"OffsetY",CONFIG_TYPE_STRING);
cfg_int_to_string(value,settings.display.y);
config_setting_set_string(setting,value);
setting = config_setting_add(group,"Mode",CONFIG_TYPE_STRING);
cfg_int_to_string(value,settings.display.mode);
config_setting_set_string(setting,value);
setting = config_setting_add(group,"Interlace",CONFIG_TYPE_BOOL);
config_setting_set_bool(setting,settings.display.interlace);
}
group = config_setting_add(ps2,"Sound",CONFIG_TYPE_GROUP);
{
setting = config_setting_add(group,"Stereo",CONFIG_TYPE_BOOL);
config_setting_set_bool(setting,settings.sound.stereo);
setting = config_setting_add(group,"Volume",CONFIG_TYPE_STRING);
cfg_int_to_string(value,settings.sound.volume);
config_setting_set_string(setting,value);
}
group = config_setting_add(ps2,"Font",CONFIG_TYPE_GROUP);
{
setting = config_setting_add(group,"Height",CONFIG_TYPE_STRING);
cfg_int_to_string(value,settings.font.height);
config_setting_set_string(setting,value);
setting = config_setting_add(group,"Color",CONFIG_TYPE_ARRAY);
for (i = 0; i < 4; i++)
{
cfg_int_to_string(value,settings.font.color[i]);
config_setting_set_string_elem(setting,-1,value);
}
setting = config_setting_add(group,"Highlight",CONFIG_TYPE_ARRAY);
for (i = 0; i < 4; i++)
{
cfg_int_to_string(value,settings.font.highlight[i]);
config_setting_set_string_elem(setting,-1,value);
}
}
group = config_setting_add(ps2,"Input",CONFIG_TYPE_GROUP);
{
setting = config_setting_add(group,"Port",CONFIG_TYPE_STRING);
cfg_int_to_string(value,settings.input.port);
config_setting_set_string(setting,value);
setting = config_setting_add(group,"Slot",CONFIG_TYPE_STRING);
cfg_int_to_string(value,settings.input.slot);
config_setting_set_string(setting,value);
setting = config_setting_add(group,"Confirm",CONFIG_TYPE_STRING);
if (settings.input.confirm == PAD_CROSS)
{
config_setting_set_string(setting,"X");
}
else
{
config_setting_set_string(setting,"O");
}
}
group = config_setting_add(ps2,"Devices",CONFIG_TYPE_GROUP);
{
setting = config_setting_add(group,"Mass",CONFIG_TYPE_BOOL);
config_setting_set_bool(setting,settings.devices.mass);
setting = config_setting_add(group,"HDD",CONFIG_TYPE_BOOL);
config_setting_set_bool(setting,settings.devices.hdd);
}
}
}
