X-Git-Url: https://git.wpitchoune.net/gitweb/?p=psensor-pkg-ubuntu.git;a=blobdiff_plain;f=src%2Fcfg.c;h=8f229754048e931a92d1d7e4251181f2980aeda5;hp=a5014ff58a9deb68d2399eaef87a69e71a94be14;hb=refs%2Ftags%2Fupstream%2F1.1.1;hpb=0470c31b8a4293914a6fd9b089503775706da084 diff --git a/src/cfg.c b/src/cfg.c index a5014ff..8f22975 100644 --- a/src/cfg.c +++ b/src/cfg.c @@ -16,110 +16,156 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA * 02110-1301 USA */ + +#include #include #include #include #include +#include +#include -#include "cfg.h" -#include +#include +#include +#define _(str) gettext(str) -static const char *KEY_SENSORS = "/apps/psensor/sensors"; +#include -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"; +#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_ENABLED = "enabled"; +static const char *ATT_SENSOR_GRAPH_ENABLED = "graph_enabled"; static const char *ATT_SENSOR_NAME = "name"; -static const char *ATT_SENSOR_APPINDICATOR_DISABLED = "appindicator/disabled"; +static const char *ATT_SENSOR_APPINDICATOR_MENU_DISABLED += "appindicator_menu_disabled"; static const char *ATT_SENSOR_APPINDICATOR_LABEL_ENABLED -= "appindicator/menu/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 -= "/apps/psensor/sensor/update_interval"; += "sensor-update-interval"; -static const char *KEY_GRAPH_UPDATE_INTERVAL -= "/apps/psensor/graph/update_interval"; +/* Graph settings */ +static const char *KEY_GRAPH_UPDATE_INTERVAL = "graph-update-interval"; -static const char *KEY_GRAPH_MONITORING_DURATION -= "/apps/psensor/graph/monitoring_duration"; +static const char *KEY_GRAPH_MONITORING_DURATION = "graph-monitoring-duration"; -static const char *KEY_GRAPH_BACKGROUND_COLOR -= "/apps/psensor/graph/background_color"; +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 -= "/apps/psensor/graph/background_alpha"; +static const char *KEY_GRAPH_BACKGROUND_ALPHA = "graph-background-alpha"; static const char *KEY_GRAPH_FOREGROUND_COLOR -= "/apps/psensor/graph/foreground_color"; += "graph-foreground-color"; + static const char *DEFAULT_GRAPH_FOREGROUND_COLOR = "#000000000000"; -static const char *KEY_ALPHA_CHANNEL_ENABLED -= "/apps/psensor/graph/alpha_channel_enabled"; +static const char *KEY_ALPHA_CHANNEL_ENABLED = "graph-alpha-channel-enabled"; +/* Inteface settings */ static const char *KEY_INTERFACE_SENSORLIST_POSITION -= "/apps/psensor/interface/sensorlist_position"; += "interface-sensorlist-position"; static const char *KEY_INTERFACE_WINDOW_DECORATION_DISABLED -= "/apps/psensor/interface/window_decoration_disabled"; += "interface-window-decoration-disabled"; static const char *KEY_INTERFACE_WINDOW_KEEP_BELOW_ENABLED -= "/apps/psensor/interface/window_keep_below_enabled"; += "interface-window-keep-below-enabled"; static const char *KEY_INTERFACE_MENU_BAR_DISABLED -= "/apps/psensor/interface/menu_bar_disabled"; += "interface-menu-bar-disabled"; static const char *KEY_INTERFACE_UNITY_LAUNCHER_COUNT_DISABLED -= "/apps/psensor/interface/unity_launcher_count_disabled"; += "interface-unity-launcher-count-disabled"; static const char *KEY_INTERFACE_HIDE_ON_STARTUP -= "/apps/psensor/interface/hide_on_startup"; += "interface-hide-on-startup"; static const char *KEY_INTERFACE_WINDOW_RESTORE_ENABLED -= "/apps/psensor/interface/window_restore_enabled"; += "interface-window-restore-enabled"; -static const char *KEY_INTERFACE_WINDOW_X = "/apps/psensor/interface/window_x"; -static const char *KEY_INTERFACE_WINDOW_Y = "/apps/psensor/interface/window_y"; -static const char *KEY_INTERFACE_WINDOW_W = "/apps/psensor/interface/window_w"; -static const char *KEY_INTERFACE_WINDOW_H = "/apps/psensor/interface/window_h"; +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 -= "/apps/psensor/interface/window_divider_pos"; += "interface-window-divider-pos"; static const char *KEY_INTERFACE_TEMPERATURE_UNIT -= "/apps/psensor/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"; + +static GSettings *settings; + +static char *user_dir; -static const char *KEY_SLOG_ENABLED = "/apps/psensor/slog/enabled"; -static const char *KEY_SLOG_INTERVAL = "/apps/psensor/slog/interval"; +static GKeyFile *key_file; -static const char *KEY_NOTIFICATION_SCRIPT = "/apps/psensor/notif_script"; +static char *sensor_config_path; -static GConfClient *client; +static void (*slog_enabled_cbk)(void *); -static char *get_string(const char *key, const char *default_value) +static char *get_string(const char *key) { - char *value; + return g_settings_get_string(settings, key); +} - value = gconf_client_get_string(client, key, NULL); +static void set_string(const char *key, const char *str) +{ + g_settings_set_string(settings, key, str); +} - if (!value) { - value = strdup(default_value); - gconf_client_set_string(client, key, default_value, NULL); - } +static void set_bool(const char *k, bool b) +{ + g_settings_set_boolean(settings, k, b); +} + +static bool get_bool(const char *k) +{ + return g_settings_get_boolean(settings, k); +} - return value; +static void set_int(const char *k, int i) +{ + g_settings_set_int(settings, k, i); +} + +static double get_double(const char *k) +{ + return g_settings_get_double(settings, k); +} + +static void set_double(const char *k, double d) +{ + g_settings_set_double(settings, k, d); +} + +static int get_int(const char *k) +{ + return g_settings_get_int(settings, k); } char *config_get_notif_script() { char *str; - str = gconf_client_get_string(client, KEY_NOTIFICATION_SCRIPT, NULL); + str = get_string(KEY_NOTIFICATION_SCRIPT); if (str && !strlen(str)) { free(str); str = NULL; @@ -131,11 +177,9 @@ char *config_get_notif_script() void config_set_notif_script(const char *str) { if (str && strlen(str) > 0) - gconf_client_set_string(client, - KEY_NOTIFICATION_SCRIPT, str, NULL); + set_string(KEY_NOTIFICATION_SCRIPT, str); else - gconf_client_set_string(client, - KEY_NOTIFICATION_SCRIPT, "", NULL); + set_string(KEY_NOTIFICATION_SCRIPT, ""); } static struct color *get_background_color() @@ -143,14 +187,13 @@ static struct color *get_background_color() char *scolor; struct color *c; - scolor = get_string(KEY_GRAPH_BACKGROUND_COLOR, - DEFAULT_GRAPH_BACKGROUND_COLOR); + scolor = get_string(KEY_GRAPH_BACKGROUND_COLOR); c = str_to_color(scolor); free(scolor); if (!c) - return color_new(0xffff, 0xffff, 0xffff); + return color_new(1, 1, 1); return c; } @@ -160,49 +203,45 @@ static struct color *get_foreground_color() char *scolor; struct color *c; - scolor = get_string(KEY_GRAPH_FOREGROUND_COLOR, - DEFAULT_GRAPH_FOREGROUND_COLOR); + scolor = get_string(KEY_GRAPH_FOREGROUND_COLOR); c = str_to_color(scolor); free(scolor); if (!c) - return color_new(0x0000, 0x0000, 0x0000); + return color_new(0, 0, 0); return c; } static bool is_alpha_channel_enabled() { - return gconf_client_get_bool(client, KEY_ALPHA_CHANNEL_ENABLED, NULL); + return get_bool(KEY_ALPHA_CHANNEL_ENABLED); +} + +static void set_alpha_channeld_enabled(bool b) +{ + set_bool(KEY_ALPHA_CHANNEL_ENABLED, b); } static enum sensorlist_position get_sensorlist_position() { - return gconf_client_get_int(client, - KEY_INTERFACE_SENSORLIST_POSITION, NULL); + return get_int(KEY_INTERFACE_SENSORLIST_POSITION); } static void set_sensorlist_position(enum sensorlist_position pos) { - gconf_client_set_int(client, - KEY_INTERFACE_SENSORLIST_POSITION, pos, NULL); + set_int(KEY_INTERFACE_SENSORLIST_POSITION, pos); } static double get_graph_background_alpha() { - double a; - - a = gconf_client_get_float(client, KEY_GRAPH_BACKGROUND_ALPHA, NULL); - if (a == 0) - gconf_client_set_float(client, - KEY_GRAPH_BACKGROUND_ALPHA, 1.0, NULL); - return a; + return get_double(KEY_GRAPH_BACKGROUND_ALPHA); } static void set_graph_background_alpha(double alpha) { - gconf_client_set_float(client, KEY_GRAPH_BACKGROUND_ALPHA, alpha, NULL); + set_double(KEY_GRAPH_BACKGROUND_ALPHA, alpha); } static void set_background_color(const struct color *color) @@ -213,8 +252,7 @@ static void set_background_color(const struct color *color) if (!scolor) scolor = strdup(DEFAULT_GRAPH_BACKGROUND_COLOR); - gconf_client_set_string(client, - KEY_GRAPH_BACKGROUND_COLOR, scolor, NULL); + set_string(KEY_GRAPH_BACKGROUND_COLOR, scolor); free(scolor); } @@ -227,468 +265,495 @@ static void set_foreground_color(const struct color *color) if (!str) str = strdup(DEFAULT_GRAPH_FOREGROUND_COLOR); - gconf_client_set_string(client, KEY_GRAPH_FOREGROUND_COLOR, str, NULL); + set_string(KEY_GRAPH_FOREGROUND_COLOR, str); free(str); } -static char *get_sensor_att_key(const char *sid, const char *att) +bool is_slog_enabled() { - char *esc_sid, *key; - - esc_sid = gconf_escape_key(sid, -1); - /* [KEY_SENSORS]/[esc_sid]/[att] */ - key = malloc(strlen(KEY_SENSORS) - + 1 + 2 * strlen(esc_sid) - + 1 + strlen(att) + 1); - - sprintf(key, "%s/%s/%s", KEY_SENSORS, esc_sid, att); - - free(esc_sid); + return get_bool(KEY_SLOG_ENABLED); +} - return key; +static void set_slog_enabled(bool enabled) +{ + set_bool(KEY_SLOG_ENABLED, enabled); } -struct color * -config_get_sensor_color(const char *sid, const struct color *dft) +static void slog_enabled_changed_cbk(GSettings *settings, + gchar *key, + gpointer data) { - char *key, *scolor; - struct color *color; + if (slog_enabled_cbk) + slog_enabled_cbk(data); +} - key = get_sensor_att_key(sid, ATT_SENSOR_COLOR); +void config_set_slog_enabled_changed_cbk(void (*cbk)(void *), void *data) +{ + log_fct_enter(); - scolor = gconf_client_get_string(client, key, NULL); + slog_enabled_cbk = cbk; - color = NULL; + g_signal_connect_after(settings, + "changed::slog-enabled", + G_CALLBACK(slog_enabled_changed_cbk), + data); - if (scolor) - color = str_to_color(scolor); + log_fct_exit(); +} - if (!scolor || !color) { - color = color_new(dft->red, dft->green, dft->blue); - scolor = color_to_str(color); - gconf_client_set_string(client, key, scolor, NULL); - } +int config_get_slog_interval() +{ + return get_int(KEY_SLOG_INTERVAL); +} - free(scolor); - free(key); +static void set_slog_interval(int interval) +{ + if (interval <= 0) + interval = 300; - return color; + set_int(KEY_SLOG_INTERVAL, interval); } -void config_set_sensor_color(const char *sid, const struct color *color) +static bool is_window_decoration_enabled() { - char *key, *scolor; + return !get_bool(KEY_INTERFACE_WINDOW_DECORATION_DISABLED); +} - key = get_sensor_att_key(sid, ATT_SENSOR_COLOR); - scolor = color_to_str(color); +static bool is_window_keep_below_enabled() +{ + return get_bool(KEY_INTERFACE_WINDOW_KEEP_BELOW_ENABLED); +} - gconf_client_set_string(client, key, scolor, NULL); +static void set_window_decoration_enabled(bool enabled) +{ + set_bool(KEY_INTERFACE_WINDOW_DECORATION_DISABLED, !enabled); +} - free(scolor); - free(key); +static void set_window_keep_below_enabled(bool enabled) +{ + set_bool(KEY_INTERFACE_WINDOW_KEEP_BELOW_ENABLED, enabled); } -int config_get_sensor_alarm_high_threshold(const char *sid) +static void init() { - int res; - char *key; + log_fct_enter(); - key = get_sensor_att_key(sid, ATT_SENSOR_ALARM_HIGH_THRESHOLD); - res = gconf_client_get_int(client, key, NULL); - free(key); + if (!settings) + settings = g_settings_new("psensor"); - return res; + log_fct_exit(); } -void -config_set_sensor_alarm_high_threshold(const char *sid, int threshold) +void config_cleanup() { - char *key; + config_sync(); - key = get_sensor_att_key(sid, ATT_SENSOR_ALARM_HIGH_THRESHOLD); - gconf_client_set_int(client, key, threshold, NULL); - free(key); -} + if (settings) { + g_settings_sync(); + g_object_unref(settings); + settings = NULL; + } -int config_get_sensor_alarm_low_threshold(const char *sid) -{ - int res; - char *key; + if (user_dir) { + free(user_dir); + user_dir = NULL; + } - key = get_sensor_att_key(sid, ATT_SENSOR_ALARM_LOW_THRESHOLD); - res = gconf_client_get_int(client, key, NULL); - free(key); + if (key_file) { + g_key_file_free(key_file); + key_file = NULL; + } + + if (sensor_config_path) { + free(sensor_config_path); + sensor_config_path = NULL; + } - return res; + slog_enabled_cbk = NULL; } -void -config_set_sensor_alarm_low_threshold(const char *sid, int threshold) +struct config *config_load() { - char *key; + struct config *c; - key = get_sensor_att_key(sid, ATT_SENSOR_ALARM_LOW_THRESHOLD); - gconf_client_set_int(client, key, threshold, NULL); - free(key); -} + init(); -bool config_get_sensor_alarm_enabled(const char *sid) -{ - gboolean b; - char *key; + c = malloc(sizeof(struct config)); - key = get_sensor_att_key(sid, ATT_SENSOR_ALARM_ENABLED); - b = gconf_client_get_bool(client, key, NULL); - free(key); + 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->sensorlist_position = get_sensorlist_position(); + c->window_decoration_enabled = is_window_decoration_enabled(); + c->window_keep_below_enabled = is_window_keep_below_enabled(); + c->slog_enabled = is_slog_enabled(); + c->slog_interval = config_get_slog_interval(); - return b; -} + c->sensor_update_interval + = get_int(KEY_SENSOR_UPDATE_INTERVAL); + if (c->sensor_update_interval < 1) + c->sensor_update_interval = 1; -void config_set_sensor_alarm_enabled(const char *sid, bool enabled) -{ - char *key; + 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->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; + + c->menu_bar_disabled = get_bool(KEY_INTERFACE_MENU_BAR_DISABLED); + + c->unity_launcher_count_disabled + = get_bool(KEY_INTERFACE_UNITY_LAUNCHER_COUNT_DISABLED); + + c->hide_on_startup = get_bool(KEY_INTERFACE_HIDE_ON_STARTUP); + + c->window_restore_enabled + = get_bool(KEY_INTERFACE_WINDOW_RESTORE_ENABLED); - key = get_sensor_att_key(sid, ATT_SENSOR_ALARM_ENABLED); - gconf_client_set_bool(client, key, enabled, NULL); - free(key); + 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->temperature_unit = get_int(KEY_INTERFACE_TEMPERATURE_UNIT); + + return c; } -bool config_is_sensor_enabled(const char *sid) +void config_save(const struct config *c) { - gboolean b; - char *key; + 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_sensorlist_position(c->sensorlist_position); + set_window_decoration_enabled(c->window_decoration_enabled); + set_window_keep_below_enabled(c->window_keep_below_enabled); + 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_MENU_BAR_DISABLED, c->menu_bar_disabled); + + set_bool(KEY_INTERFACE_UNITY_LAUNCHER_COUNT_DISABLED, + c->unity_launcher_count_disabled); + + set_bool(KEY_INTERFACE_HIDE_ON_STARTUP, c->hide_on_startup); + + set_bool(KEY_INTERFACE_WINDOW_RESTORE_ENABLED, + c->window_restore_enabled); + + 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); - key = get_sensor_att_key(sid, ATT_SENSOR_ENABLED); - b = gconf_client_get_bool(client, key, NULL); - free(key); + set_int(KEY_INTERFACE_WINDOW_DIVIDER_POS, c->window_divider_pos); - return b; + set_int(KEY_INTERFACE_TEMPERATURE_UNIT, c->temperature_unit); } -void config_set_sensor_enabled(const char *sid, bool enabled) +const char *get_psensor_user_dir() { - char *key; + const char *home; + + log_fct_enter(); + + if (!user_dir) { + home = getenv("HOME"); + + if (!home) + return NULL; + + user_dir = path_append(home, ".psensor"); - key = get_sensor_att_key(sid, ATT_SENSOR_ENABLED); - gconf_client_set_bool(client, key, enabled, NULL); - free(key); + if (mkdir(user_dir, 0700) == -1 && errno != EEXIST) { + log_err(_("Failed to create the directory %s: %s"), + user_dir, + strerror(errno)); + + free(user_dir); + user_dir = NULL; + } + } + + log_fct_exit(); + + return user_dir; } -char *config_get_sensor_name(const char *sid) +static const char *get_sensor_config_path() { - char *name, *key; + const char *dir; - key = get_sensor_att_key(sid, ATT_SENSOR_NAME); - name = gconf_client_get_string(client, key, NULL); - free(key); + if (!sensor_config_path) { + dir = get_psensor_user_dir(); - return name; + if (dir) + sensor_config_path = path_append(dir, "psensor.cfg"); + } + + return sensor_config_path; } -void config_set_sensor_name(const char *sid, const char *name) +static GKeyFile *get_sensor_key_file() { - char *key; + int ret; + GError *err; + const char *path; + + if (!key_file) { + path = get_sensor_config_path(); + + key_file = g_key_file_new(); - key = get_sensor_att_key(sid, ATT_SENSOR_NAME); - gconf_client_set_string(client, key, name, NULL); - free(key); + 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) { + if (err->code == G_KEY_FILE_ERROR_NOT_FOUND) + log_fct(_("The configuration file " + "does not exist.")); + else + log_err(_("Failed to parse configuration " + "file: %s"), + path); + } + } + + return key_file; } -int config_get_sensor_position(const char *sid) +static void save_sensor_key_file() { - char *key; - int pos; + GKeyFile *kfile; + const char *path; + char *data; - key = get_sensor_att_key(sid, ATT_SENSOR_POSITION); - pos = gconf_client_get_int(client, key, NULL); - free(key); + log_fct_enter(); - return pos; + kfile = get_sensor_key_file(); + + data = g_key_file_to_data(kfile, NULL, NULL); + + 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_set_sensor_position(const char *sid, int pos) +void config_sync() { - char *key; - - key = get_sensor_att_key(sid, ATT_SENSOR_POSITION); - gconf_client_set_int(client, key, pos, NULL); - free(key); + log_fct_enter(); + if (settings) + g_settings_sync(); + save_sensor_key_file(); + log_fct_exit(); } -bool config_is_appindicator_enabled(const char *sid) +static void sensor_set_str(const char *sid, const char *att, const char *str) { - char *key; - gboolean b; + GKeyFile *kfile; + + kfile = get_sensor_key_file(); + g_key_file_set_string(kfile, sid, att, str); +} - key = get_sensor_att_key(sid, ATT_SENSOR_APPINDICATOR_DISABLED); - b = gconf_client_get_bool(client, key, NULL); - free(key); +static char *sensor_get_str(const char *sid, const char *att) +{ + GKeyFile *kfile; - return !b; + kfile = get_sensor_key_file(); + return g_key_file_get_string(kfile, sid, att, NULL); } -void config_set_appindicator_enabled(const char *sid, bool enabled) +static bool sensor_get_bool(const char *sid, const char *att) { - char *key; + GKeyFile *kfile; - key = get_sensor_att_key(sid, ATT_SENSOR_APPINDICATOR_DISABLED); - gconf_client_set_bool(client, key, !enabled, NULL); - free(key); + kfile = get_sensor_key_file(); + return g_key_file_get_boolean(kfile, sid, att, NULL); } -bool config_is_appindicator_label_enabled(const char *sid) +static void sensor_set_bool(const char *sid, const char *att, bool enabled) { - char *key; - gboolean b; + GKeyFile *kfile; - key = get_sensor_att_key(sid, ATT_SENSOR_APPINDICATOR_LABEL_ENABLED); - b = gconf_client_get_bool(client, key, NULL); - free(key); + kfile = get_sensor_key_file(); - return b; + g_key_file_set_boolean(kfile, sid, att, enabled); } -void config_set_appindicator_label_enabled(const char *sid, bool enabled) +static int sensor_get_int(const char *sid, const char *att) { - char *key; + GKeyFile *kfile; - key = get_sensor_att_key(sid, ATT_SENSOR_APPINDICATOR_LABEL_ENABLED); - gconf_client_set_bool(client, key, enabled, NULL); - free(key); + kfile = get_sensor_key_file(); + return g_key_file_get_integer(kfile, sid, att, NULL); } -bool is_slog_enabled() +static void sensor_set_int(const char *sid, const char *att, int i) { - return gconf_client_get_bool(client, KEY_SLOG_ENABLED, NULL); + GKeyFile *kfile; + + kfile = get_sensor_key_file(); + + g_key_file_set_integer(kfile, sid, att, i); } -static void set_slog_enabled(bool enabled) +char *config_get_sensor_name(const char *sid) { - gconf_client_set_bool(client, KEY_SLOG_ENABLED, enabled, NULL); + return sensor_get_str(sid, ATT_SENSOR_NAME); } -void config_slog_enabled_notify_add(GConfClientNotifyFunc cbk, void *data) +void config_set_sensor_name(const char *sid, const char *name) { - log_debug("config_slog_enabled_notify_add"); - gconf_client_add_dir(client, - KEY_SLOG_ENABLED, - GCONF_CLIENT_PRELOAD_NONE, - NULL); - gconf_client_notify_add(client, - KEY_SLOG_ENABLED, - cbk, - data, - NULL, - NULL); + sensor_set_str(sid, ATT_SENSOR_NAME, name); } -int config_get_slog_interval() +void config_set_sensor_color(const char *sid, const struct color *color) { - int res; + char *scolor; - res = gconf_client_get_int(client, KEY_SLOG_INTERVAL, NULL); + scolor = color_to_str(color); - if (res <= 0) - return 300; - else - return res; + sensor_set_str(sid, ATT_SENSOR_COLOR, scolor); + + free(scolor); } -static void set_slog_interval(int interval) +struct color * +config_get_sensor_color(const char *sid, const struct color *dft) { - if (interval <= 0) - interval = 300; + char *scolor; + struct color *color; + + scolor = sensor_get_str(sid, ATT_SENSOR_COLOR); - gconf_client_set_int(client, KEY_SLOG_INTERVAL, interval, NULL); + if (scolor) + color = str_to_color(scolor); + else + color = NULL; + + if (!color) { + color = color_new(dft->red, dft->green, dft->blue); + config_set_sensor_color(sid, color); + } + + free(scolor); + + return color; } -static bool is_window_decoration_enabled() +bool config_is_sensor_graph_enabled(const char *sid) { - return !gconf_client_get_bool(client, - KEY_INTERFACE_WINDOW_DECORATION_DISABLED, - NULL); + return sensor_get_bool(sid, ATT_SENSOR_GRAPH_ENABLED); } -static bool is_window_keep_below_enabled() +void config_set_sensor_graph_enabled(const char *sid, bool enabled) { - return gconf_client_get_bool(client, - KEY_INTERFACE_WINDOW_KEEP_BELOW_ENABLED, - NULL); + sensor_set_bool(sid, ATT_SENSOR_GRAPH_ENABLED, enabled); } -static void set_window_decoration_enabled(bool enabled) +int config_get_sensor_alarm_high_threshold(const char *sid) { - gconf_client_set_bool - (client, - KEY_INTERFACE_WINDOW_DECORATION_DISABLED, !enabled, NULL); + return sensor_get_int(sid, ATT_SENSOR_ALARM_HIGH_THRESHOLD); } -static void set_window_keep_below_enabled(bool enabled) +void config_set_sensor_alarm_high_threshold(const char *sid, int threshold) { - gconf_client_set_bool(client, - KEY_INTERFACE_WINDOW_KEEP_BELOW_ENABLED, - enabled, NULL); + sensor_set_int(sid, ATT_SENSOR_ALARM_HIGH_THRESHOLD, threshold); } -/* - * Initializes the GConf client. - */ -static void init() +int config_get_sensor_alarm_low_threshold(const char *sid) { - if (!client) - client = gconf_client_get_default(); + return sensor_get_int(sid, ATT_SENSOR_ALARM_LOW_THRESHOLD); } -void config_cleanup() +void config_set_sensor_alarm_low_threshold(const char *sid, int threshold) { - if (client) { - g_object_unref(client); - client = NULL; - } + sensor_set_int(sid, ATT_SENSOR_ALARM_LOW_THRESHOLD, threshold); } -struct config *config_load() +bool config_is_appindicator_enabled(const char *sid) { - 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->sensorlist_position = get_sensorlist_position(); - c->window_decoration_enabled = is_window_decoration_enabled(); - c->window_keep_below_enabled = is_window_keep_below_enabled(); - c->slog_enabled = is_slog_enabled(); - c->slog_interval = config_get_slog_interval(); - - 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; - - 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; - - c->graph_monitoring_duration - = gconf_client_get_int(client, KEY_GRAPH_MONITORING_DURATION, NULL); - - if (c->graph_monitoring_duration < 1) - c->graph_monitoring_duration = 10; - - 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; + return !sensor_get_bool(sid, ATT_SENSOR_APPINDICATOR_MENU_DISABLED); +} - c->menu_bar_disabled - = gconf_client_get_bool(client, - KEY_INTERFACE_MENU_BAR_DISABLED, - NULL); +void config_set_appindicator_enabled(const char *sid, bool enabled) +{ + return sensor_set_bool(sid, + ATT_SENSOR_APPINDICATOR_MENU_DISABLED, + !enabled); +} - c->unity_launcher_count_disabled - = gconf_client_get_bool - (client, - KEY_INTERFACE_UNITY_LAUNCHER_COUNT_DISABLED, - NULL); +int config_get_sensor_position(const char *sid) +{ + return sensor_get_int(sid, ATT_SENSOR_POSITION); +} - c->hide_on_startup - = gconf_client_get_bool(client, - KEY_INTERFACE_HIDE_ON_STARTUP, - NULL); +void config_set_sensor_position(const char *sid, int pos) +{ + return sensor_set_int(sid, ATT_SENSOR_POSITION, pos); +} - 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); +bool config_get_sensor_alarm_enabled(const char *sid) +{ + return sensor_get_bool(sid, ATT_SENSOR_ALARM_ENABLED); +} - if (!c->window_restore_enabled || !c->window_w || !c->window_h) { - c->window_w = 800; - c->window_h = 200; - } +void config_set_sensor_alarm_enabled(const char *sid, bool enabled) +{ + sensor_set_bool(sid, ATT_SENSOR_ALARM_ENABLED, enabled); +} - c->temperature_unit = gconf_client_get_int - (client, KEY_INTERFACE_TEMPERATURE_UNIT, NULL); +bool config_is_sensor_enabled(const char *sid) +{ + return !sensor_get_bool(sid, ATT_SENSOR_HIDE); +} - return c; +void config_set_sensor_enabled(const char *sid, bool enabled) +{ + sensor_set_bool(sid, ATT_SENSOR_HIDE, !enabled); } -void config_save(const struct config *c) +bool config_is_appindicator_label_enabled(const char *sid) { - set_background_color(c->graph_bgcolor); - set_foreground_color(c->graph_fgcolor); - set_graph_background_alpha(c->graph_bg_alpha); - set_sensorlist_position(c->sensorlist_position); - set_window_decoration_enabled(c->window_decoration_enabled); - set_window_keep_below_enabled(c->window_keep_below_enabled); - set_slog_enabled(c->slog_enabled); - set_slog_interval(c->slog_interval); + return sensor_get_bool(sid, ATT_SENSOR_APPINDICATOR_LABEL_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); - - gconf_client_set_int(client, - KEY_INTERFACE_TEMPERATURE_UNIT, - c->temperature_unit, - NULL); +void config_set_appindicator_label_enabled(const char *sid, bool enabled) +{ + sensor_set_bool(sid, ATT_SENSOR_APPINDICATOR_LABEL_ENABLED, enabled); }