X-Git-Url: http://wpitchoune.net/gitweb/?p=psensor-pkg-debian.git;a=blobdiff_plain;f=src%2Fcfg.c;h=d94f256aa221a8fdbb5c41b13ba2fad3756c39c8;hp=606ecc46dc9fdd38e1bdd8b56ea01d83865528ed;hb=bd7036af56a4b61b2b473dccbeac5e26f78b57da;hpb=f055e7507526592d3a74c652f5f053701614c9c0 diff --git a/src/cfg.c b/src/cfg.c index 606ecc4..d94f256 100644 --- a/src/cfg.c +++ b/src/cfg.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2010-2012 jeanfi@gmail.com + * Copyright (C) 2010-2016 jeanfi@gmail.com * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as @@ -16,541 +16,939 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA * 02110-1301 USA */ + +#include #include #include #include #include +#include +#include + +#include +#include +#define _(str) gettext(str) + +#include +#include +#include +#include + +/* Properties of each sensor */ +static const char *ATT_SENSOR_ALARM_ENABLED = "alarm_enabled"; +static const char *ATT_SENSOR_ALARM_HIGH_THRESHOLD = "alarm_high_threshold"; +static const char *ATT_SENSOR_ALARM_LOW_THRESHOLD = "alarm_low_threshold"; +static const char *ATT_SENSOR_COLOR = "color"; +static const char *ATT_SENSOR_GRAPH_ENABLED = "graph_enabled"; +static const char *ATT_SENSOR_NAME = "name"; +static const char *ATT_SENSOR_APPINDICATOR_MENU_DISABLED += "appindicator_menu_disabled"; +static const char *ATT_SENSOR_APPINDICATOR_LABEL_ENABLED += "appindicator_label_enabled"; +static const char *ATT_SENSOR_POSITION = "position"; +static const char *ATT_SENSOR_HIDE = "hide"; + +/* Update interval of the measures of the sensors */ +static const char *KEY_SENSOR_UPDATE_INTERVAL += "sensor-update-interval"; + +/* Graph settings */ +static const char *KEY_GRAPH_UPDATE_INTERVAL = "graph-update-interval"; +static const char *KEY_GRAPH_MONITORING_DURATION = "graph-monitoring-duration"; +static const char *KEY_GRAPH_BACKGROUND_COLOR = "graph-background-color"; +static const char *DEFAULT_GRAPH_BACKGROUND_COLOR = "#e8f4e8f4a8f5"; +static const char *KEY_GRAPH_BACKGROUND_ALPHA = "graph-background-alpha"; +static const char *KEY_GRAPH_FOREGROUND_COLOR += "graph-foreground-color"; +static const char *KEY_GRAPH_SMOOTH_CURVES_ENABLED += "graph-smooth-curves-enabled"; + +static const char *DEFAULT_GRAPH_FOREGROUND_COLOR = "#000000000000"; + +static const char *KEY_ALPHA_CHANNEL_ENABLED = "graph-alpha-channel-enabled"; + +/* Inteface settings */ +static const char *KEY_INTERFACE_SENSORLIST_POSITION += "interface-sensorlist-position"; + +static const char *KEY_INTERFACE_WINDOW_DECORATION_DISABLED += "interface-window-decoration-disabled"; + +static const char *KEY_INTERFACE_WINDOW_KEEP_BELOW_ENABLED += "interface-window-keep-below-enabled"; + +static const char *KEY_INTERFACE_MENU_BAR_DISABLED += "interface-menu-bar-disabled"; + +static const char *KEY_INTERFACE_UNITY_LAUNCHER_COUNT_DISABLED += "interface-unity-launcher-count-disabled"; + +static const char *KEY_INTERFACE_HIDE_ON_STARTUP += "interface-hide-on-startup"; + +static const char *KEY_INTERFACE_WINDOW_RESTORE_ENABLED += "interface-window-restore-enabled"; + +static const char *KEY_INTERFACE_WINDOW_X = "interface-window-x"; +static const char *KEY_INTERFACE_WINDOW_Y = "interface-window-y"; +static const char *KEY_INTERFACE_WINDOW_W = "interface-window-w"; +static const char *KEY_INTERFACE_WINDOW_H = "interface-window-h"; + +static const char *KEY_INTERFACE_WINDOW_DIVIDER_POS += "interface-window-divider-pos"; + +static const char *KEY_INTERFACE_TEMPERATURE_UNIT += "interface-temperature-unit"; + +/* Sensor logging settings */ +static const char *KEY_SLOG_ENABLED = "slog-enabled"; +static const char *KEY_SLOG_INTERVAL = "slog-interval"; + +/* Path to the script called when a notification is raised */ +static const char *KEY_NOTIFICATION_SCRIPT = "notif-script"; + +/* Provider settings */ +static const char *KEY_PROVIDER_LMSENSORS_ENABLED += "provider-lmsensors-enabled"; +static const char *KEY_PROVIDER_ATIADLSDK_ENABLED += "provider-atiadlsdk-enabled"; +static const char *KEY_PROVIDER_GTOP2_ENABLED = "provider-gtop2-enabled"; +static const char *KEY_PROVIDER_HDDTEMP_ENABLED = "provider-hddtemp-enabled"; +static const char *KEY_PROVIDER_LIBATASMART_ENABLED += "provider-libatasmart-enabled"; +static const char *KEY_PROVIDER_NVCTRL_ENABLED = "provider-nvctrl-enabled"; +static const char *KEY_PROVIDER_UDISKS2_ENABLED = "provider-udisks2-enabled"; + +static const char *KEY_DEFAULT_HIGH_THRESHOLD_TEMPERATURE += "default-high-threshold-temperature"; +static const char *KEY_DEFAULT_SENSOR_ALARM_ENABLED += "default-sensor-alarm-enabled"; + +static GSettings *settings; + +static char *user_dir; + +static GKeyFile *key_file; + +static char *sensor_config_path; + +static void (*slog_enabled_cbk)(void *); -#include +static char *get_string(const char *key) +{ + return g_settings_get_string(settings, key); +} -#include "cfg.h" +static void set_string(const char *key, const char *str) +{ + g_settings_set_string(settings, key, str); +} -#define KEY_SENSOR_UPDATE_INTERVAL "/apps/psensor/sensor/update_interval" +static void set_bool(const char *k, bool b) +{ + g_settings_set_boolean(settings, k, b); +} -#define KEY_GRAPH_UPDATE_INTERVAL "/apps/psensor/graph/update_interval" -#define KEY_GRAPH_MONITORING_DURATION "/apps/psensor/graph/monitoring_duration" +static bool get_bool(const char *k) +{ + return g_settings_get_boolean(settings, k); +} -#define KEY_GRAPH_BACKGROUND_COLOR "/apps/psensor/graph/background_color" -#define DEFAULT_GRAPH_BACKGROUND_COLOR "#e8f4e8f4a8f5" +static void set_int(const char *k, int i) +{ + g_settings_set_int(settings, k, i); +} -#define KEY_GRAPH_BACKGROUND_ALPHA "/apps/psensor/graph/background_alpha" -#define DEFAULT_GRAPH_BACKGROUND_ALPHA "1.0" +static double get_double(const char *k) +{ + return g_settings_get_double(settings, k); +} -#define KEY_GRAPH_FOREGROUND_COLOR "/apps/psensor/graph/foreground_color" -#define DEFAULT_GRAPH_FOREGROUND_COLOR "#000000000000" +static void set_double(const char *k, double d) +{ + g_settings_set_double(settings, k, d); +} -#define KEY_ALPHA_CHANNEL_ENABLED "/apps/psensor/graph/alpha_channel_enabled" -#define DEFAULT_ALPHA_CHANNEL_ENABLED 0 +static int get_int(const char *k) +{ + return g_settings_get_int(settings, k); +} + +char *config_get_notif_script(void) +{ + char *str; + + str = get_string(KEY_NOTIFICATION_SCRIPT); + if (str && !strlen(str)) { + free(str); + str = NULL; + } + + return str; +} -#define KEY_INTERFACE_SENSORLIST_POSITION \ -"/apps/psensor/interface/sensorlist_position" +void config_set_notif_script(const char *str) +{ + if (str && strlen(str) > 0) + set_string(KEY_NOTIFICATION_SCRIPT, str); + else + set_string(KEY_NOTIFICATION_SCRIPT, ""); +} + +static struct color *get_background_color(void) +{ + char *scolor; + struct color *c; + + scolor = get_string(KEY_GRAPH_BACKGROUND_COLOR); + + c = str_to_color(scolor); + free(scolor); -#define KEY_INTERFACE_WINDOW_DECORATION_DISABLED \ -"/apps/psensor/interface/window_decoration_disabled" + if (!c) + return color_new(1, 1, 1); -#define KEY_INTERFACE_WINDOW_KEEP_BELOW_ENABLED \ -"/apps/psensor/interface/window_keep_below_enabled" + return c; +} -#define KEY_INTERFACE_MENU_BAR_DISABLED \ -"/apps/psensor/interface/menu_bar_disabled" +static struct color *get_foreground_color(void) +{ + char *scolor; + struct color *c; -#define KEY_INTERFACE_UNITY_LAUNCHER_COUNT_DISABLED \ -"/apps/psensor/interface/unity_launcher_count_disabled" + scolor = get_string(KEY_GRAPH_FOREGROUND_COLOR); -#define KEY_INTERFACE_HIDE_ON_STARTUP \ -"/apps/psensor/interface/hide_on_startup" + c = str_to_color(scolor); + free(scolor); -#define KEY_INTERFACE_WINDOW_RESTORE_ENABLED \ -"/apps/psensor/interface/window_restore_enabled" + if (!c) + return color_new(0, 0, 0); -#define KEY_INTERFACE_WINDOW_X "/apps/psensor/interface/window_x" -#define KEY_INTERFACE_WINDOW_Y "/apps/psensor/interface/window_y" -#define KEY_INTERFACE_WINDOW_W "/apps/psensor/interface/window_w" -#define KEY_INTERFACE_WINDOW_H "/apps/psensor/interface/window_h" + return c; +} -#define KEY_INTERFACE_WINDOW_DIVIDER_POS \ -"/apps/psensor/interface/window_divider_pos" +static bool is_alpha_channel_enabled(void) +{ + return get_bool(KEY_ALPHA_CHANNEL_ENABLED); +} -GConfClient *client; +static void set_alpha_channeld_enabled(bool b) +{ + set_bool(KEY_ALPHA_CHANNEL_ENABLED, b); +} -static char *get_string(char *key, char *default_value) +enum sensorlist_position config_get_sensorlist_position(void) { - char *value = gconf_client_get_string(client, - key, - NULL); + return get_int(KEY_INTERFACE_SENSORLIST_POSITION); +} - if (!value) { - value = strdup(default_value); +void config_set_sensorlist_position(enum sensorlist_position pos) +{ + set_int(KEY_INTERFACE_SENSORLIST_POSITION, pos); +} - gconf_client_set_string(client, key, default_value, NULL); - } +static double get_graph_background_alpha(void) +{ + return get_double(KEY_GRAPH_BACKGROUND_ALPHA); +} - return value; +static void set_graph_background_alpha(double alpha) +{ + set_double(KEY_GRAPH_BACKGROUND_ALPHA, alpha); } -static struct color *config_get_background_color() +static void set_background_color(const struct color *color) { + char *scolor; - char *scolor = get_string(KEY_GRAPH_BACKGROUND_COLOR, - DEFAULT_GRAPH_BACKGROUND_COLOR); + scolor = color_to_str(color); + if (!scolor) + scolor = strdup(DEFAULT_GRAPH_BACKGROUND_COLOR); - struct color *c = string_to_color(scolor); + set_string(KEY_GRAPH_BACKGROUND_COLOR, scolor); free(scolor); +} - if (c == NULL) - return color_new(0xffff, 0xffff, 0xffff); +static void set_foreground_color(const struct color *color) +{ + char *str; - return c; + str = color_to_str(color); + if (!str) + str = strdup(DEFAULT_GRAPH_FOREGROUND_COLOR); + + set_string(KEY_GRAPH_FOREGROUND_COLOR, str); + + free(str); } -static struct color *config_get_foreground_color() +bool is_slog_enabled(void) { - char *scolor = get_string(KEY_GRAPH_FOREGROUND_COLOR, - DEFAULT_GRAPH_FOREGROUND_COLOR); + return get_bool(KEY_SLOG_ENABLED); +} - struct color *c = string_to_color(scolor); +static void set_slog_enabled(bool enabled) +{ + set_bool(KEY_SLOG_ENABLED, enabled); +} - free(scolor); +static void slog_enabled_changed_cbk(GSettings *settings, + gchar *key, + gpointer data) +{ + if (slog_enabled_cbk) + slog_enabled_cbk(data); +} + +void config_set_slog_enabled_changed_cbk(void (*cbk)(void *), void *data) +{ + log_fct_enter(); - if (c == NULL) - return color_new(0x0000, 0x0000, 0x0000); + slog_enabled_cbk = cbk; - return c; + g_signal_connect_after(settings, + "changed::slog-enabled", + G_CALLBACK(slog_enabled_changed_cbk), + data); + + log_fct_exit(); +} + +int config_get_slog_interval(void) +{ + return get_int(KEY_SLOG_INTERVAL); } -static int config_is_alpha_channel_enabled() +static void set_slog_interval(int interval) { - gboolean b = gconf_client_get_bool(client, - KEY_ALPHA_CHANNEL_ENABLED, - NULL); + if (interval <= 0) + interval = 300; - return b == TRUE; + set_int(KEY_SLOG_INTERVAL, interval); } -static int config_get_sensorlist_position() +bool config_is_window_decoration_enabled(void) { - return gconf_client_get_int(client, - KEY_INTERFACE_SENSORLIST_POSITION, NULL); + return !get_bool(KEY_INTERFACE_WINDOW_DECORATION_DISABLED); } -static void config_set_sensorlist_position(int pos) +bool config_is_window_keep_below_enabled(void) { - gconf_client_set_int(client, - KEY_INTERFACE_SENSORLIST_POSITION, pos, NULL); + return get_bool(KEY_INTERFACE_WINDOW_KEEP_BELOW_ENABLED); } -static double config_get_graph_background_alpha() +void config_set_window_decoration_enabled(bool enabled) { - double a = gconf_client_get_float(client, - KEY_GRAPH_BACKGROUND_ALPHA, - NULL); + set_bool(KEY_INTERFACE_WINDOW_DECORATION_DISABLED, !enabled); +} - if (a == 0) - gconf_client_set_float(client, - KEY_GRAPH_BACKGROUND_ALPHA, 1.0, NULL); - return a; +void config_set_window_keep_below_enabled(bool enabled) +{ + set_bool(KEY_INTERFACE_WINDOW_KEEP_BELOW_ENABLED, enabled); } -static void config_set_graph_background_alpha(double alpha) +bool config_is_smooth_curves_enabled(void) { - gconf_client_set_float(client, KEY_GRAPH_BACKGROUND_ALPHA, alpha, NULL); + return get_bool(KEY_GRAPH_SMOOTH_CURVES_ENABLED); } -static void config_set_background_color(struct color *color) +void config_set_smooth_curves_enabled(bool b) { - char *scolor = color_to_string(color); + set_bool(KEY_GRAPH_SMOOTH_CURVES_ENABLED, b); +} - if (!scolor) - scolor = strdup(DEFAULT_GRAPH_BACKGROUND_COLOR); +double config_get_default_high_threshold_temperature(void) +{ + return get_double(KEY_DEFAULT_HIGH_THRESHOLD_TEMPERATURE); +} - gconf_client_set_string(client, - KEY_GRAPH_BACKGROUND_COLOR, scolor, NULL); +static bool config_get_default_sensor_alarm_enabled(void) +{ + return get_bool(KEY_DEFAULT_SENSOR_ALARM_ENABLED); +} - free(scolor); +static void init(void) +{ + log_fct_enter(); + + if (!settings) + settings = g_settings_new("psensor"); + + log_fct_exit(); } -static void config_set_foreground_color(struct color *color) +void config_cleanup(void) { - char *scolor = color_to_string(color); + config_sync(); - if (!scolor) - scolor = strdup(DEFAULT_GRAPH_FOREGROUND_COLOR); + if (settings) { + g_settings_sync(); + g_object_unref(settings); + settings = NULL; + } - gconf_client_set_string(client, - KEY_GRAPH_FOREGROUND_COLOR, scolor, NULL); + if (user_dir) { + free(user_dir); + user_dir = NULL; + } - free(scolor); + if (key_file) { + g_key_file_free(key_file); + key_file = NULL; + } + + if (sensor_config_path) { + free(sensor_config_path); + sensor_config_path = NULL; + } + + slog_enabled_cbk = NULL; +} + +struct config *config_load(void) +{ + struct config *c; + + init(); + + c = malloc(sizeof(struct config)); + + c->graph_bgcolor = get_background_color(); + c->graph_fgcolor = get_foreground_color(); + c->graph_bg_alpha = get_graph_background_alpha(); + c->alpha_channel_enabled = is_alpha_channel_enabled(); + c->slog_enabled = is_slog_enabled(); + c->slog_interval = config_get_slog_interval(); + + c->sensor_update_interval + = get_int(KEY_SENSOR_UPDATE_INTERVAL); + if (c->sensor_update_interval < 1) + c->sensor_update_interval = 1; + + c->graph_update_interval = get_int(KEY_GRAPH_UPDATE_INTERVAL); + if (c->graph_update_interval < 1) + c->graph_update_interval = 1; + + c->graph_monitoring_duration = get_int(KEY_GRAPH_MONITORING_DURATION); + + if (c->graph_monitoring_duration < 1) + c->graph_monitoring_duration = 10; + + c->window_restore_enabled + = get_bool(KEY_INTERFACE_WINDOW_RESTORE_ENABLED); + + c->window_x = get_int(KEY_INTERFACE_WINDOW_X); + c->window_y = get_int(KEY_INTERFACE_WINDOW_Y); + c->window_w = get_int(KEY_INTERFACE_WINDOW_W); + c->window_h = get_int(KEY_INTERFACE_WINDOW_H); + + c->window_divider_pos = get_int(KEY_INTERFACE_WINDOW_DIVIDER_POS); + + if (!c->window_restore_enabled || !c->window_w || !c->window_h) { + c->window_w = 800; + c->window_h = 200; + } + + c->sensor_values_max_length = compute_values_max_length(c); + + return c; } -static char *config_get_sensor_key(char *sensor_name) +void config_save(const struct config *c) { - char *escaped_name = gconf_escape_key(sensor_name, -1); - /* /apps/psensor/sensors/[sensor_name]/color */ - char *key = malloc(22 + 2 * strlen(escaped_name) + 6 + 1); + set_alpha_channeld_enabled(c->alpha_channel_enabled); + set_background_color(c->graph_bgcolor); + set_foreground_color(c->graph_fgcolor); + set_graph_background_alpha(c->graph_bg_alpha); + set_slog_enabled(c->slog_enabled); + set_slog_interval(c->slog_interval); + + set_int(KEY_GRAPH_UPDATE_INTERVAL, c->graph_update_interval); + + set_int(KEY_GRAPH_MONITORING_DURATION, c->graph_monitoring_duration); + + set_int(KEY_SENSOR_UPDATE_INTERVAL, c->sensor_update_interval); + + set_bool(KEY_INTERFACE_HIDE_ON_STARTUP, c->hide_on_startup); - sprintf(key, "/apps/psensor/sensors/%s/color", escaped_name); + set_bool(KEY_INTERFACE_WINDOW_RESTORE_ENABLED, + c->window_restore_enabled); - free(escaped_name); + set_int(KEY_INTERFACE_WINDOW_X, c->window_x); + set_int(KEY_INTERFACE_WINDOW_Y, c->window_y); + set_int(KEY_INTERFACE_WINDOW_W, c->window_w); + set_int(KEY_INTERFACE_WINDOW_H, c->window_h); - return key; + set_int(KEY_INTERFACE_WINDOW_DIVIDER_POS, c->window_divider_pos); } -struct color *config_get_sensor_color(char *sensor_name, - struct color *default_color) +const char *get_psensor_user_dir(void) { - char *key = config_get_sensor_key(sensor_name); + const char *home; - char *scolor = gconf_client_get_string(client, - key, - NULL); + log_fct_enter(); - struct color *color = NULL; + if (!user_dir) { + home = getenv("HOME"); - if (scolor) - color = string_to_color(scolor); + if (!home) + return NULL; - if (!scolor || !color) { - color = color_new(default_color->red, - default_color->green, default_color->blue); + user_dir = path_append(home, ".psensor"); - scolor = color_to_string(color); + if (mkdir(user_dir, 0700) == -1 && errno != EEXIST) { + log_err(_("Failed to create the directory %s: %s"), + user_dir, + strerror(errno)); - gconf_client_set_string(client, key, scolor, NULL); + free(user_dir); + user_dir = NULL; + } } - free(scolor); - free(key); + log_fct_exit(); - return color; + return user_dir; } -void config_set_sensor_color(char *sensor_name, struct color *color) +static const char *get_sensor_config_path(void) { - char *key = config_get_sensor_key(sensor_name); + const char *dir; - char *scolor = color_to_string(color); + if (!sensor_config_path) { + dir = get_psensor_user_dir(); - gconf_client_set_string(client, key, scolor, NULL); + if (dir) + sensor_config_path = path_append(dir, "psensor.cfg"); + } - free(scolor); + return sensor_config_path; +} + +static GKeyFile *get_sensor_key_file(void) +{ + int ret; + GError *err; + const char *path; + + if (!key_file) { + path = get_sensor_config_path(); + + key_file = g_key_file_new(); + + err = NULL; + ret = g_key_file_load_from_file(key_file, + path, + G_KEY_FILE_KEEP_COMMENTS + | G_KEY_FILE_KEEP_TRANSLATIONS, + &err); + + if (!ret) { + log_warn(_("Failed to load configuration file %s: %s"), + path, + err->message); + g_error_free(err); + } + } + + return key_file; } -int config_get_sensor_alarm_limit(char *sensor_name, int def) +static void save_sensor_key_file(void) { - int res; - char *escaped_name = gconf_escape_key(sensor_name, -1); - /* /apps/psensor/sensors/[sensor_name]/alarmlimit */ - char *key = malloc(22 + 2 * strlen(escaped_name) + 1 + 10 + 1); + GKeyFile *kfile; + const char *path; + char *data; - sprintf(key, "/apps/psensor/sensors/%s/alarmlimit", escaped_name); + log_fct_enter(); - res = gconf_client_get_int(client, key, NULL); + kfile = get_sensor_key_file(); - free(escaped_name); + data = g_key_file_to_data(kfile, NULL, NULL); - return res ? res : def; + path = get_sensor_config_path(); + + if (!g_file_set_contents(path, data, -1, NULL)) + log_err(_("Failed to save configuration file %s."), path); + + free(data); + + log_fct_exit(); +} + +void config_sync(void) +{ + log_fct_enter(); + if (settings) + g_settings_sync(); + save_sensor_key_file(); + log_fct_exit(); } -void config_set_sensor_alarm_limit(char *sensor_name, int alarm_limit) +static void sensor_set_str(const char *sid, const char *att, const char *str) { - char *escaped_name = gconf_escape_key(sensor_name, -1); - /* /apps/psensor/sensors/[sensor_name]/alarmlimit */ - char *key = malloc(22 + 2 * strlen(escaped_name) + 1 + 10 + 1); + GKeyFile *kfile; - sprintf(key, "/apps/psensor/sensors/%s/alarmlimit", escaped_name); + kfile = get_sensor_key_file(); + g_key_file_set_string(kfile, sid, att, str); +} - gconf_client_set_int(client, key, alarm_limit, NULL); +static char *sensor_get_str(const char *sid, const char *att) +{ + GKeyFile *kfile; - free(escaped_name); + kfile = get_sensor_key_file(); + return g_key_file_get_string(kfile, sid, att, NULL); } -int config_get_sensor_alarm_enabled(char *sid) +static bool sensor_get_double(const char *sid, const char *att, double *d) { - gboolean res; - char *escaped_name = gconf_escape_key(sid, -1); - /* /apps/psensor/sensors/[sensor_name]/alarmenabled */ - char *key = malloc(22 + 2 * strlen(escaped_name) + 1 + 12 + 1); + GKeyFile *kfile; + GError *err; + double v; - sprintf(key, "/apps/psensor/sensors/%s/alarmenabled", escaped_name); + kfile = get_sensor_key_file(); - res = gconf_client_get_bool(client, key, NULL); + err = NULL; + v = g_key_file_get_double(kfile, sid, att, &err); - free(escaped_name); + if (err) { + log_err(err->message); - return res == TRUE; + g_error_free(err); + + return false; + } + + *d = v; + return true; } -void config_set_sensor_alarm_enabled(char *sid, int enabled) +static bool sensor_get_bool(const char *sid, const char *att, bool dft) { - char *escaped_name = gconf_escape_key(sid, -1); - /* /apps/psensor/sensors/[sensor_name]/alarmenabled */ - char *key = malloc(22 + 2 * strlen(escaped_name) + 1 + 12 + 1); + GKeyFile *kfile; + GError *err; + bool ret; + + kfile = get_sensor_key_file(); - sprintf(key, "/apps/psensor/sensors/%s/alarmenabled", escaped_name); + err = NULL; + ret = g_key_file_get_boolean(kfile, sid, att, &err); - gconf_client_set_bool(client, key, enabled, NULL); + if (err) { + if (err->code == G_KEY_FILE_ERROR_KEY_NOT_FOUND) + ret = dft; + else + log_err(err->message); - free(escaped_name); + g_error_free(err); + } + + return ret; } -int config_is_sensor_enabled(char *sid) +static void sensor_set_bool(const char *sid, const char *att, bool enabled) { - gboolean res; - char *escaped_name = gconf_escape_key(sid, -1); - /* /apps/psensor/sensors/[sensor_name]/enabled */ - char *key = malloc(22 + 2 * strlen(escaped_name) + 1 + 7 + 1); + GKeyFile *kfile; - sprintf(key, "/apps/psensor/sensors/%s/enabled", escaped_name); + kfile = get_sensor_key_file(); - res = gconf_client_get_bool(client, key, NULL); + g_key_file_set_boolean(kfile, sid, att, enabled); +} - free(escaped_name); +static int sensor_get_int(const char *sid, const char *att) +{ + GKeyFile *kfile; + + kfile = get_sensor_key_file(); + return g_key_file_get_integer(kfile, sid, att, NULL); +} + +static void sensor_set_int(const char *sid, const char *att, int i) +{ + GKeyFile *kfile; + + kfile = get_sensor_key_file(); + + g_key_file_set_integer(kfile, sid, att, i); +} - return res == TRUE; +char *config_get_sensor_name(const char *sid) +{ + return sensor_get_str(sid, ATT_SENSOR_NAME); +} +void config_set_sensor_name(const char *sid, const char *name) +{ + sensor_set_str(sid, ATT_SENSOR_NAME, name); } -void config_set_sensor_enabled(char *sid, int enabled) +void config_set_sensor_color(const char *sid, const GdkRGBA *color) { - char *escaped_name = gconf_escape_key(sid, -1); - /* /apps/psensor/sensors/[sensor_name]/enabled */ - char *key = malloc(22 + 2 * strlen(escaped_name) + 1 + 7 + 1); + gchar *str; + + str = gdk_rgba_to_string(color); - sprintf(key, "/apps/psensor/sensors/%s/enabled", escaped_name); + sensor_set_str(sid, ATT_SENSOR_COLOR, str); - gconf_client_set_bool(client, key, enabled, NULL); + g_free(str); +} + +static const char *next_default_color(void) +{ + /* copied from the default colors of the gtk color color + * chooser. + */ + const char *default_colors[27] = { + "#ef2929", /* Scarlet Red */ + "#fcaf3e", /* Orange */ + "#fce94f", /* Butter */ + "#8ae234", /* Chameleon */ + "#729fcf", /* Sky Blue */ + "#ad7fa8", /* Plum */ + "#e9b96e", /* Chocolate */ + "#888a85", /* Aluminum 1 */ + "#eeeeec", /* Aluminum 2 */ + "#cc0000", + "#f57900", + "#edd400", + "#73d216", + "#3465a4", + "#75507b", + "#c17d11", + "#555753", + "#d3d7cf", + "#a40000", + "#ce5c00", + "#c4a000", + "#4e9a06", + "#204a87", + "#5c3566", + "#8f5902", + "#2e3436", + "#babdb6" + }; + static int next_idx; + const char *c; + + c = default_colors[next_idx % 27]; + + next_idx++; - free(escaped_name); + return c; } -char *config_get_sensor_name(char *sid) +GdkRGBA *config_get_sensor_color(const char *sid) { - char *res; - char *escaped_name = gconf_escape_key(sid, -1); - /* /apps/psensor/sensors/[sensor_name]/name */ - char *key = malloc(22 + 2 * strlen(escaped_name) + 1 + 4 + 1); + GdkRGBA rgba; + char *str; + gboolean ret; - sprintf(key, "/apps/psensor/sensors/%s/name", escaped_name); + str = sensor_get_str(sid, ATT_SENSOR_COLOR); - res = gconf_client_get_string(client, key, NULL); + if (str) { + ret = gdk_rgba_parse(&rgba, str); + free(str); + } - free(escaped_name); + if (!str || !ret) { + gdk_rgba_parse(&rgba, next_default_color()); + config_set_sensor_color(sid, &rgba); + } - return res; + return gdk_rgba_copy(&rgba); } -void config_set_sensor_name(char *sid, const char *name) +bool config_is_sensor_graph_enabled(const char *sid) { - char *escaped_name = gconf_escape_key(sid, -1); - /* /apps/psensor/sensors/[sensor_name]/name */ - char *key = malloc(22 + 2 * strlen(escaped_name) + 1 + 4 + 1); + return sensor_get_bool(sid, ATT_SENSOR_GRAPH_ENABLED, false); +} - sprintf(key, "/apps/psensor/sensors/%s/name", escaped_name); +void config_set_sensor_graph_enabled(const char *sid, bool enabled) +{ + sensor_set_bool(sid, ATT_SENSOR_GRAPH_ENABLED, enabled); +} - gconf_client_set_string(client, key, name, NULL); +bool config_get_sensor_alarm_high_threshold(const char *sid, double *v) +{ + return sensor_get_double(sid, ATT_SENSOR_ALARM_HIGH_THRESHOLD, v); +} - free(escaped_name); +void config_set_sensor_alarm_high_threshold(const char *sid, int threshold) +{ + sensor_set_int(sid, ATT_SENSOR_ALARM_HIGH_THRESHOLD, threshold); } -static int config_is_window_decoration_enabled() +bool config_get_sensor_alarm_low_threshold(const char *sid, double *v) { - gboolean b; + return sensor_get_double(sid, ATT_SENSOR_ALARM_LOW_THRESHOLD, v); +} - b = gconf_client_get_bool(client, - KEY_INTERFACE_WINDOW_DECORATION_DISABLED, - NULL); +void config_set_sensor_alarm_low_threshold(const char *sid, int threshold) +{ + sensor_set_int(sid, ATT_SENSOR_ALARM_LOW_THRESHOLD, threshold); +} - return b == FALSE; +bool config_is_appindicator_enabled(const char *sid) +{ + return !sensor_get_bool(sid, + ATT_SENSOR_APPINDICATOR_MENU_DISABLED, + false); } -static int config_is_window_keep_below_enabled() +void config_set_appindicator_enabled(const char *sid, bool enabled) { - gboolean b; + sensor_set_bool(sid, + ATT_SENSOR_APPINDICATOR_MENU_DISABLED, + !enabled); +} - b = gconf_client_get_bool(client, - KEY_INTERFACE_WINDOW_KEEP_BELOW_ENABLED, - NULL); +int config_get_sensor_position(const char *sid) +{ + return sensor_get_int(sid, ATT_SENSOR_POSITION); +} - return b == TRUE; +void config_set_sensor_position(const char *sid, int pos) +{ + sensor_set_int(sid, ATT_SENSOR_POSITION, pos); } -static void config_set_window_decoration_enabled(int enabled) +bool config_get_sensor_alarm_enabled(const char *sid) { - if (enabled) - gconf_client_set_bool - (client, - KEY_INTERFACE_WINDOW_DECORATION_DISABLED, FALSE, NULL); - else - gconf_client_set_bool - (client, - KEY_INTERFACE_WINDOW_DECORATION_DISABLED, TRUE, NULL); + return sensor_get_bool(sid, ATT_SENSOR_ALARM_ENABLED, false); } -static void config_set_window_keep_below_enabled(int enabled) +void config_set_sensor_alarm_enabled(const char *sid, bool enabled) { - if (enabled) - gconf_client_set_bool(client, - KEY_INTERFACE_WINDOW_KEEP_BELOW_ENABLED, - TRUE, NULL); - else - gconf_client_set_bool(client, - KEY_INTERFACE_WINDOW_KEEP_BELOW_ENABLED, - FALSE, NULL); + sensor_set_bool(sid, ATT_SENSOR_ALARM_ENABLED, enabled); } -void config_init() +bool config_is_sensor_enabled(const char *sid) { - client = gconf_client_get_default(); + return !sensor_get_bool(sid, + ATT_SENSOR_HIDE, + config_get_default_sensor_alarm_enabled()); } -void config_cleanup() +void config_set_sensor_enabled(const char *sid, bool enabled) { - if (client) { - g_object_unref(client); - client = NULL; - } + sensor_set_bool(sid, ATT_SENSOR_HIDE, !enabled); } -struct config *config_load() +bool config_is_appindicator_label_enabled(const char *sid) { - struct config *c; + return sensor_get_bool(sid, + ATT_SENSOR_APPINDICATOR_LABEL_ENABLED, + false); +} - c = malloc(sizeof(struct config)); +void config_set_appindicator_label_enabled(const char *sid, bool enabled) +{ + sensor_set_bool(sid, ATT_SENSOR_APPINDICATOR_LABEL_ENABLED, enabled); +} - c->graph_bgcolor = config_get_background_color(); - c->graph_fgcolor = config_get_foreground_color(); - c->graph_bg_alpha = config_get_graph_background_alpha(); - c->alpha_channel_enabled = config_is_alpha_channel_enabled(); - c->sensorlist_position = config_get_sensorlist_position(); - c->window_decoration_enabled = config_is_window_decoration_enabled(); - c->window_keep_below_enabled = config_is_window_keep_below_enabled(); +GSettings *config_get_GSettings(void) +{ + return settings; +} - c->sensor_update_interval - = gconf_client_get_int(client, KEY_SENSOR_UPDATE_INTERVAL, NULL); - if (c->sensor_update_interval < 1) - c->sensor_update_interval = 1; +bool config_is_lmsensor_enabled(void) +{ + return get_bool(KEY_PROVIDER_LMSENSORS_ENABLED); +} - c->graph_update_interval - = gconf_client_get_int(client, KEY_GRAPH_UPDATE_INTERVAL, NULL); - if (c->graph_update_interval < 1) - c->graph_update_interval = 1; +bool config_is_gtop2_enabled(void) +{ + return get_bool(KEY_PROVIDER_GTOP2_ENABLED); +} - c->graph_monitoring_duration - = gconf_client_get_int(client, KEY_GRAPH_MONITORING_DURATION, NULL); +bool config_is_udisks2_enabled(void) +{ + return get_bool(KEY_PROVIDER_UDISKS2_ENABLED); +} - if (c->graph_monitoring_duration < 1) - c->graph_monitoring_duration = 10; +bool config_is_hddtemp_enabled(void) +{ + return get_bool(KEY_PROVIDER_HDDTEMP_ENABLED); +} - c->sensor_values_max_length - = - (c->graph_monitoring_duration * 60) / c->sensor_update_interval; - if (c->sensor_values_max_length < 3) - c->sensor_values_max_length = 3; +bool config_is_libatasmart_enabled(void) +{ + return get_bool(KEY_PROVIDER_LIBATASMART_ENABLED); +} - c->menu_bar_disabled - = gconf_client_get_bool(client, - KEY_INTERFACE_MENU_BAR_DISABLED, - NULL); +bool config_is_nvctrl_enabled(void) +{ + return get_bool(KEY_PROVIDER_NVCTRL_ENABLED); +} - c->unity_launcher_count_disabled - = gconf_client_get_bool - (client, - KEY_INTERFACE_UNITY_LAUNCHER_COUNT_DISABLED, - NULL); +bool config_is_atiadlsdk_enabled(void) +{ + return get_bool(KEY_PROVIDER_ATIADLSDK_ENABLED); +} - c->hide_on_startup - = gconf_client_get_bool(client, - KEY_INTERFACE_HIDE_ON_STARTUP, - NULL); +void config_set_lmsensor_enable(bool b) +{ + set_bool(KEY_PROVIDER_LMSENSORS_ENABLED, b); +} - c->window_restore_enabled - = gconf_client_get_bool(client, - KEY_INTERFACE_WINDOW_RESTORE_ENABLED, - NULL); - - c->window_x = gconf_client_get_int(client, - KEY_INTERFACE_WINDOW_X, - NULL); - c->window_y = gconf_client_get_int(client, - KEY_INTERFACE_WINDOW_Y, - NULL); - c->window_w = gconf_client_get_int(client, - KEY_INTERFACE_WINDOW_W, - NULL); - c->window_h = gconf_client_get_int(client, - KEY_INTERFACE_WINDOW_H, - NULL); - c->window_divider_pos - = gconf_client_get_int(client, - KEY_INTERFACE_WINDOW_DIVIDER_POS, - NULL); +void config_set_nvctrl_enable(bool b) +{ + set_bool(KEY_PROVIDER_NVCTRL_ENABLED, b); +} - if (!c->window_restore_enabled || !c->window_w || !c->window_h) { - c->window_w = 800; - c->window_h = 200; - } +void config_set_atiadlsdk_enable(bool b) +{ + set_bool(KEY_PROVIDER_ATIADLSDK_ENABLED, b); +} - return c; +void config_set_gtop2_enable(bool b) +{ + set_bool(KEY_PROVIDER_GTOP2_ENABLED, b); +} + +void config_set_hddtemp_enable(bool b) +{ + set_bool(KEY_PROVIDER_HDDTEMP_ENABLED, b); +} + +void config_set_libatasmart_enable(bool b) +{ + set_bool(KEY_PROVIDER_LIBATASMART_ENABLED, b); } -void config_save(struct config *c) -{ - config_set_background_color(c->graph_bgcolor); - config_set_foreground_color(c->graph_fgcolor); - config_set_graph_background_alpha(c->graph_bg_alpha); - config_set_sensorlist_position(c->sensorlist_position); - config_set_window_decoration_enabled(c->window_decoration_enabled); - config_set_window_keep_below_enabled(c->window_keep_below_enabled); - - gconf_client_set_int(client, - KEY_GRAPH_UPDATE_INTERVAL, - c->graph_update_interval, NULL); - - gconf_client_set_int(client, - KEY_GRAPH_MONITORING_DURATION, - c->graph_monitoring_duration, NULL); - - gconf_client_set_int(client, - KEY_SENSOR_UPDATE_INTERVAL, - c->sensor_update_interval, NULL); - - gconf_client_set_bool(client, - KEY_INTERFACE_MENU_BAR_DISABLED, - c->menu_bar_disabled, NULL); - - gconf_client_set_bool(client, - KEY_INTERFACE_UNITY_LAUNCHER_COUNT_DISABLED, - c->unity_launcher_count_disabled, NULL); - - gconf_client_set_bool(client, - KEY_INTERFACE_HIDE_ON_STARTUP, - c->hide_on_startup, NULL); - - gconf_client_set_bool(client, - KEY_INTERFACE_WINDOW_RESTORE_ENABLED, - c->window_restore_enabled, - NULL); - - gconf_client_set_int(client, - KEY_INTERFACE_WINDOW_X, - c->window_x, - NULL); - gconf_client_set_int(client, - KEY_INTERFACE_WINDOW_Y, - c->window_y, - NULL); - gconf_client_set_int(client, - KEY_INTERFACE_WINDOW_W, - c->window_w, - NULL); - gconf_client_set_int(client, - KEY_INTERFACE_WINDOW_H, - c->window_h, - NULL); - - gconf_client_set_int(client, - KEY_INTERFACE_WINDOW_DIVIDER_POS, - c->window_divider_pos, - NULL); +void config_set_udisks2_enable(bool b) +{ + set_bool(KEY_PROVIDER_UDISKS2_ENABLED, b); +} + +enum temperature_unit config_get_temperature_unit(void) +{ + return get_int(KEY_INTERFACE_TEMPERATURE_UNIT); +} + +void config_set_temperature_unit(enum temperature_unit u) +{ + set_int(KEY_INTERFACE_TEMPERATURE_UNIT, u); +} + +bool config_is_menu_bar_enabled(void) +{ + return !get_bool(KEY_INTERFACE_MENU_BAR_DISABLED); +} + +void config_set_menu_bar_enabled(bool enabled) +{ + set_bool(KEY_INTERFACE_MENU_BAR_DISABLED, !enabled); +} + +bool config_is_count_visible(void) +{ + return !get_bool(KEY_INTERFACE_UNITY_LAUNCHER_COUNT_DISABLED); +} + +void config_set_count_visible(bool visible) +{ + set_bool(KEY_INTERFACE_UNITY_LAUNCHER_COUNT_DISABLED, !visible); }