src/cfg.c

   1 /*
   2  * Copyright (C) 2010-2014 jeanfi@gmail.com
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  17  * 02110-1301 USA
  18  */
  19
  20 #include <errno.h>
  21 #include <stdlib.h>
  22 #include <stdio.h>
  23 #include <string.h>
  24 #include <ctype.h>
  25 #include <sys/stat.h>
  26 #include <sys/types.h>
  27
  28 #include <locale.h>
  29 #include <libintl.h>
  30 #define _(str) gettext(str)
  31
  32 #include <cfg.h>
  33 #include <graph.h>
  34 #include <pio.h>
  35 #include <plog.h>
  36
  37 /* Properties of each sensor */
  38 static const char *ATT_SENSOR_ALARM_ENABLED = "alarm_enabled";
  39 static const char *ATT_SENSOR_ALARM_HIGH_THRESHOLD = "alarm_high_threshold";
  40 static const char *ATT_SENSOR_ALARM_LOW_THRESHOLD = "alarm_low_threshold";
  41 static const char *ATT_SENSOR_COLOR = "color";
  42 static const char *ATT_SENSOR_GRAPH_ENABLED = "graph_enabled";
  43 static const char *ATT_SENSOR_NAME = "name";
  44 static const char *ATT_SENSOR_APPINDICATOR_MENU_DISABLED
  45 = "appindicator_menu_disabled";
  46 static const char *ATT_SENSOR_APPINDICATOR_LABEL_ENABLED
  47 = "appindicator_label_enabled";
  48 static const char *ATT_SENSOR_POSITION = "position";
  49 static const char *ATT_SENSOR_HIDE = "hide";
  50
  51 /* Update interval of the measures of the sensors */
  52 static const char *KEY_SENSOR_UPDATE_INTERVAL
  53 = "sensor-update-interval";
  54
  55 /* Graph settings */
  56 static const char *KEY_GRAPH_UPDATE_INTERVAL = "graph-update-interval";
  57 static const char *KEY_GRAPH_MONITORING_DURATION = "graph-monitoring-duration";
  58 static const char *KEY_GRAPH_BACKGROUND_COLOR = "graph-background-color";
  59 static const char *DEFAULT_GRAPH_BACKGROUND_COLOR = "#e8f4e8f4a8f5";
  60 static const char *KEY_GRAPH_BACKGROUND_ALPHA = "graph-background-alpha";
  61 static const char *KEY_GRAPH_FOREGROUND_COLOR
  62 = "graph-foreground-color";
  63 static const char *KEY_GRAPH_SMOOTH_CURVES_ENABLED
  64 = "graph-smooth-curves-enabled";
  65
  66 static const char *DEFAULT_GRAPH_FOREGROUND_COLOR = "#000000000000";
  67
  68 static const char *KEY_ALPHA_CHANNEL_ENABLED = "graph-alpha-channel-enabled";
  69
  70 /* Inteface settings */
  71 static const char *KEY_INTERFACE_SENSORLIST_POSITION
  72 = "interface-sensorlist-position";
  73
  74 static const char *KEY_INTERFACE_WINDOW_DECORATION_DISABLED
  75 = "interface-window-decoration-disabled";
  76
  77 static const char *KEY_INTERFACE_WINDOW_KEEP_BELOW_ENABLED
  78 = "interface-window-keep-below-enabled";
  79
  80 static const char *KEY_INTERFACE_MENU_BAR_DISABLED
  81 = "interface-menu-bar-disabled";
  82
  83 static const char *KEY_INTERFACE_UNITY_LAUNCHER_COUNT_DISABLED
  84 = "interface-unity-launcher-count-disabled";
  85
  86 static const char *KEY_INTERFACE_HIDE_ON_STARTUP
  87 = "interface-hide-on-startup";
  88
  89 static const char *KEY_INTERFACE_WINDOW_RESTORE_ENABLED
  90 = "interface-window-restore-enabled";
  91
  92 static const char *KEY_INTERFACE_WINDOW_X = "interface-window-x";
  93 static const char *KEY_INTERFACE_WINDOW_Y = "interface-window-y";
  94 static const char *KEY_INTERFACE_WINDOW_W = "interface-window-w";
  95 static const char *KEY_INTERFACE_WINDOW_H = "interface-window-h";
  96
  97 static const char *KEY_INTERFACE_WINDOW_DIVIDER_POS
  98 = "interface-window-divider-pos";
  99
 100 static const char *KEY_INTERFACE_TEMPERATURE_UNIT
 101 = "interface-temperature-unit";
 102
 103 /* Sensor logging settings */
 104 static const char *KEY_SLOG_ENABLED = "slog-enabled";
 105 static const char *KEY_SLOG_INTERVAL = "slog-interval";
 106
 107 /* Path to the script called when a notification is raised */
 108 static const char *KEY_NOTIFICATION_SCRIPT = "notif-script";
 109
 110 /* Provider settings */
 111 static const char *KEY_PROVIDER_LMSENSORS_ENABLED
 112 = "provider-lmsensors-enabled";
 113 static const char *KEY_PROVIDER_ATIADLSDK_ENABLED
 114 = "provider-atiadlsdk-enabled";
 115 static const char *KEY_PROVIDER_GTOP2_ENABLED = "provider-gtop2-enabled";
 116 static const char *KEY_PROVIDER_HDDTEMP_ENABLED = "provider-hddtemp-enabled";
 117 static const char *KEY_PROVIDER_LIBATASMART_ENABLED
 118 = "provider-libatasmart-enabled";
 119 static const char *KEY_PROVIDER_NVCTRL_ENABLED = "provider-nvctrl-enabled";
 120 static const char *KEY_PROVIDER_UDISKS2_ENABLED = "provider-udisks2-enabled";
 121
 122 static GSettings *settings;
 123
 124 static char *user_dir;
 125
 126 static GKeyFile *key_file;
 127
 128 static char *sensor_config_path;
 129
 130 static void (*slog_enabled_cbk)(void *);
 131
 132 static char *get_string(const char *key)
 133 {
 134         return g_settings_get_string(settings, key);
 135 }
 136
 137 static void set_string(const char *key, const char *str)
 138 {
 139         g_settings_set_string(settings, key, str);
 140 }
 141
 142 static void set_bool(const char *k, bool b)
 143 {
 144         g_settings_set_boolean(settings, k, b);
 145 }
 146
 147 static bool get_bool(const char *k)
 148 {
 149         return g_settings_get_boolean(settings, k);
 150 }
 151
 152 static void set_int(const char *k, int i)
 153 {
 154         g_settings_set_int(settings, k, i);
 155 }
 156
 157 static double get_double(const char *k)
 158 {
 159         return g_settings_get_double(settings, k);
 160 }
 161
 162 static void set_double(const char *k, double d)
 163 {
 164         g_settings_set_double(settings, k, d);
 165 }
 166
 167 static int get_int(const char *k)
 168 {
 169         return g_settings_get_int(settings, k);
 170 }
 171
 172 char *config_get_notif_script(void)
 173 {
 174         char *str;
 175
 176         str =  get_string(KEY_NOTIFICATION_SCRIPT);
 177         if (str && !strlen(str)) {
 178                 free(str);
 179                 str = NULL;
 180         }
 181
 182         return str;
 183 }
 184
 185 void config_set_notif_script(const char *str)
 186 {
 187         if (str && strlen(str) > 0)
 188                 set_string(KEY_NOTIFICATION_SCRIPT, str);
 189         else
 190                 set_string(KEY_NOTIFICATION_SCRIPT, "");
 191 }
 192
 193 static struct color *get_background_color(void)
 194 {
 195         char *scolor;
 196         struct color *c;
 197
 198         scolor = get_string(KEY_GRAPH_BACKGROUND_COLOR);
 199
 200         c = str_to_color(scolor);
 201         free(scolor);
 202
 203         if (!c)
 204                 return color_new(1, 1, 1);
 205
 206         return c;
 207 }
 208
 209 static struct color *get_foreground_color(void)
 210 {
 211         char *scolor;
 212         struct color *c;
 213
 214         scolor = get_string(KEY_GRAPH_FOREGROUND_COLOR);
 215
 216         c = str_to_color(scolor);
 217         free(scolor);
 218
 219         if (!c)
 220                 return color_new(0, 0, 0);
 221
 222         return c;
 223 }
 224
 225 static bool is_alpha_channel_enabled(void)
 226 {
 227         return get_bool(KEY_ALPHA_CHANNEL_ENABLED);
 228 }
 229
 230 static void set_alpha_channeld_enabled(bool b)
 231 {
 232         set_bool(KEY_ALPHA_CHANNEL_ENABLED, b);
 233 }
 234
 235 static enum sensorlist_position get_sensorlist_position(void)
 236 {
 237         return get_int(KEY_INTERFACE_SENSORLIST_POSITION);
 238 }
 239
 240 static void set_sensorlist_position(enum sensorlist_position pos)
 241 {
 242         set_int(KEY_INTERFACE_SENSORLIST_POSITION, pos);
 243 }
 244
 245 static double get_graph_background_alpha(void)
 246 {
 247         return get_double(KEY_GRAPH_BACKGROUND_ALPHA);
 248 }
 249
 250 static void set_graph_background_alpha(double alpha)
 251 {
 252         set_double(KEY_GRAPH_BACKGROUND_ALPHA, alpha);
 253 }
 254
 255 static void set_background_color(const struct color *color)
 256 {
 257         char *scolor;
 258
 259         scolor = color_to_str(color);
 260         if (!scolor)
 261                 scolor = strdup(DEFAULT_GRAPH_BACKGROUND_COLOR);
 262
 263         set_string(KEY_GRAPH_BACKGROUND_COLOR, scolor);
 264
 265         free(scolor);
 266 }
 267
 268 static void set_foreground_color(const struct color *color)
 269 {
 270         char *str;
 271
 272         str = color_to_str(color);
 273         if (!str)
 274                 str = strdup(DEFAULT_GRAPH_FOREGROUND_COLOR);
 275
 276         set_string(KEY_GRAPH_FOREGROUND_COLOR, str);
 277
 278         free(str);
 279 }
 280
 281 bool is_slog_enabled(void)
 282 {
 283         return get_bool(KEY_SLOG_ENABLED);
 284 }
 285
 286 static void set_slog_enabled(bool enabled)
 287 {
 288         set_bool(KEY_SLOG_ENABLED, enabled);
 289 }
 290
 291 static void slog_enabled_changed_cbk(GSettings *settings,
 292                                      gchar *key,
 293                                      gpointer data)
 294 {
 295         if (slog_enabled_cbk)
 296                 slog_enabled_cbk(data);
 297 }
 298
 299 void config_set_slog_enabled_changed_cbk(void (*cbk)(void *), void *data)
 300 {
 301         log_fct_enter();
 302
 303         slog_enabled_cbk = cbk;
 304
 305         g_signal_connect_after(settings,
 306                                "changed::slog-enabled",
 307                                G_CALLBACK(slog_enabled_changed_cbk),
 308                                data);
 309
 310         log_fct_exit();
 311 }
 312
 313 int config_get_slog_interval(void)
 314 {
 315         return get_int(KEY_SLOG_INTERVAL);
 316 }
 317
 318 static void set_slog_interval(int interval)
 319 {
 320         if (interval <= 0)
 321                 interval = 300;
 322
 323         set_int(KEY_SLOG_INTERVAL, interval);
 324 }
 325
 326 static bool is_window_decoration_enabled(void)
 327 {
 328         return !get_bool(KEY_INTERFACE_WINDOW_DECORATION_DISABLED);
 329 }
 330
 331 static bool is_window_keep_below_enabled(void)
 332 {
 333         return get_bool(KEY_INTERFACE_WINDOW_KEEP_BELOW_ENABLED);
 334 }
 335
 336 static void set_window_decoration_enabled(bool enabled)
 337 {
 338         set_bool(KEY_INTERFACE_WINDOW_DECORATION_DISABLED, !enabled);
 339 }
 340
 341 static void set_window_keep_below_enabled(bool enabled)
 342 {
 343         set_bool(KEY_INTERFACE_WINDOW_KEEP_BELOW_ENABLED, enabled);
 344 }
 345
 346 bool config_is_smooth_curves_enabled(void)
 347 {
 348         return get_bool(KEY_GRAPH_SMOOTH_CURVES_ENABLED);
 349 }
 350
 351 void config_set_smooth_curves_enabled(bool b)
 352 {
 353         set_bool(KEY_GRAPH_SMOOTH_CURVES_ENABLED, b);
 354 }
 355
 356
 357 static void init(void)
 358 {
 359         log_fct_enter();
 360
 361         if (!settings)
 362                 settings = g_settings_new("psensor");
 363
 364         log_fct_exit();
 365 }
 366
 367 void config_cleanup(void)
 368 {
 369         config_sync();
 370
 371         if (settings) {
 372                 g_settings_sync();
 373                 g_object_unref(settings);
 374                 settings = NULL;
 375         }
 376
 377         if (user_dir) {
 378                 free(user_dir);
 379                 user_dir = NULL;
 380         }
 381
 382         if (key_file) {
 383                 g_key_file_free(key_file);
 384                 key_file = NULL;
 385         }
 386
 387         if (sensor_config_path) {
 388                 free(sensor_config_path);
 389                 sensor_config_path = NULL;
 390         }
 391
 392         slog_enabled_cbk = NULL;
 393 }
 394
 395 struct config *config_load(void)
 396 {
 397         struct config *c;
 398
 399         init();
 400
 401         c = malloc(sizeof(struct config));
 402
 403         c->graph_bgcolor = get_background_color();
 404         c->graph_fgcolor = get_foreground_color();
 405         c->graph_bg_alpha = get_graph_background_alpha();
 406         c->alpha_channel_enabled = is_alpha_channel_enabled();
 407         c->sensorlist_position = get_sensorlist_position();
 408         c->window_decoration_enabled = is_window_decoration_enabled();
 409         c->window_keep_below_enabled = is_window_keep_below_enabled();
 410         c->slog_enabled = is_slog_enabled();
 411         c->slog_interval = config_get_slog_interval();
 412
 413         c->sensor_update_interval
 414             = get_int(KEY_SENSOR_UPDATE_INTERVAL);
 415         if (c->sensor_update_interval < 1)
 416                 c->sensor_update_interval = 1;
 417
 418         c->graph_update_interval = get_int(KEY_GRAPH_UPDATE_INTERVAL);
 419         if (c->graph_update_interval < 1)
 420                 c->graph_update_interval = 1;
 421
 422         c->graph_monitoring_duration = get_int(KEY_GRAPH_MONITORING_DURATION);
 423
 424         if (c->graph_monitoring_duration < 1)
 425                 c->graph_monitoring_duration = 10;
 426
 427         c->menu_bar_disabled = get_bool(KEY_INTERFACE_MENU_BAR_DISABLED);
 428
 429         c->unity_launcher_count_disabled
 430                 = get_bool(KEY_INTERFACE_UNITY_LAUNCHER_COUNT_DISABLED);
 431
 432         c->hide_on_startup = get_bool(KEY_INTERFACE_HIDE_ON_STARTUP);
 433
 434         c->window_restore_enabled
 435                 = get_bool(KEY_INTERFACE_WINDOW_RESTORE_ENABLED);
 436
 437         c->window_x = get_int(KEY_INTERFACE_WINDOW_X);
 438         c->window_y = get_int(KEY_INTERFACE_WINDOW_Y);
 439         c->window_w = get_int(KEY_INTERFACE_WINDOW_W);
 440         c->window_h = get_int(KEY_INTERFACE_WINDOW_H);
 441
 442         c->window_divider_pos = get_int(KEY_INTERFACE_WINDOW_DIVIDER_POS);
 443
 444         if (!c->window_restore_enabled || !c->window_w || !c->window_h) {
 445                 c->window_w = 800;
 446                 c->window_h = 200;
 447         }
 448
 449         c->temperature_unit = get_int(KEY_INTERFACE_TEMPERATURE_UNIT);
 450
 451         c->sensor_values_max_length = compute_values_max_length(c);
 452
 453         return c;
 454 }
 455
 456 void config_save(const struct config *c)
 457 {
 458         set_alpha_channeld_enabled(c->alpha_channel_enabled);
 459         set_background_color(c->graph_bgcolor);
 460         set_foreground_color(c->graph_fgcolor);
 461         set_graph_background_alpha(c->graph_bg_alpha);
 462         set_sensorlist_position(c->sensorlist_position);
 463         set_window_decoration_enabled(c->window_decoration_enabled);
 464         set_window_keep_below_enabled(c->window_keep_below_enabled);
 465         set_slog_enabled(c->slog_enabled);
 466         set_slog_interval(c->slog_interval);
 467
 468         set_int(KEY_GRAPH_UPDATE_INTERVAL, c->graph_update_interval);
 469
 470         set_int(KEY_GRAPH_MONITORING_DURATION, c->graph_monitoring_duration);
 471
 472         set_int(KEY_SENSOR_UPDATE_INTERVAL, c->sensor_update_interval);
 473
 474         set_bool(KEY_INTERFACE_MENU_BAR_DISABLED, c->menu_bar_disabled);
 475
 476         set_bool(KEY_INTERFACE_UNITY_LAUNCHER_COUNT_DISABLED,
 477                  c->unity_launcher_count_disabled);
 478
 479         set_bool(KEY_INTERFACE_HIDE_ON_STARTUP, c->hide_on_startup);
 480
 481         set_bool(KEY_INTERFACE_WINDOW_RESTORE_ENABLED,
 482                  c->window_restore_enabled);
 483
 484         set_int(KEY_INTERFACE_WINDOW_X, c->window_x);
 485         set_int(KEY_INTERFACE_WINDOW_Y, c->window_y);
 486         set_int(KEY_INTERFACE_WINDOW_W, c->window_w);
 487         set_int(KEY_INTERFACE_WINDOW_H, c->window_h);
 488
 489         set_int(KEY_INTERFACE_WINDOW_DIVIDER_POS, c->window_divider_pos);
 490
 491         set_int(KEY_INTERFACE_TEMPERATURE_UNIT, c->temperature_unit);
 492 }
 493
 494 const char *get_psensor_user_dir(void)
 495 {
 496         const char *home;
 497
 498         log_fct_enter();
 499
 500         if (!user_dir) {
 501                 home = getenv("HOME");
 502
 503                 if (!home)
 504                         return NULL;
 505
 506                 user_dir = path_append(home, ".psensor");
 507
 508                 if (mkdir(user_dir, 0700) == -1 && errno != EEXIST) {
 509                         log_err(_("Failed to create the directory %s: %s"),
 510                                 user_dir,
 511                                 strerror(errno));
 512
 513                         free(user_dir);
 514                         user_dir = NULL;
 515                 }
 516         }
 517
 518         log_fct_exit();
 519
 520         return user_dir;
 521 }
 522
 523 static const char *get_sensor_config_path(void)
 524 {
 525         const char *dir;
 526
 527         if (!sensor_config_path) {
 528                 dir = get_psensor_user_dir();
 529
 530                 if (dir)
 531                         sensor_config_path = path_append(dir, "psensor.cfg");
 532         }
 533
 534         return sensor_config_path;
 535 }
 536
 537 static GKeyFile *get_sensor_key_file(void)
 538 {
 539         int ret;
 540         GError *err;
 541         const char *path;
 542
 543         if (!key_file) {
 544                 path = get_sensor_config_path();
 545
 546                 key_file = g_key_file_new();
 547
 548                 err = NULL;
 549                 ret = g_key_file_load_from_file(key_file,
 550                                                 path,
 551                                                 G_KEY_FILE_KEEP_COMMENTS
 552                                                 | G_KEY_FILE_KEEP_TRANSLATIONS,
 553                                                 &err);
 554
 555                 if (!ret)
 556                         log_warn(_("Failed to load configuration file %s: %s"),
 557                                  path,
 558                                  err->message);
 559         }
 560
 561         return key_file;
 562 }
 563
 564 static void save_sensor_key_file(void)
 565 {
 566         GKeyFile *kfile;
 567         const char *path;
 568         char *data;
 569
 570         log_fct_enter();
 571
 572         kfile = get_sensor_key_file();
 573
 574         data = g_key_file_to_data(kfile, NULL, NULL);
 575
 576         path = get_sensor_config_path();
 577
 578         if (!g_file_set_contents(path, data, -1, NULL))
 579                 log_err(_("Failed to save configuration file %s."), path);
 580
 581         free(data);
 582
 583         log_fct_exit();
 584 }
 585
 586 void config_sync(void)
 587 {
 588         log_fct_enter();
 589         if (settings)
 590                 g_settings_sync();
 591         save_sensor_key_file();
 592         log_fct_exit();
 593 }
 594
 595 static void sensor_set_str(const char *sid, const char *att, const char *str)
 596 {
 597         GKeyFile *kfile;
 598
 599         kfile = get_sensor_key_file();
 600         g_key_file_set_string(kfile, sid, att, str);
 601 }
 602
 603 static char *sensor_get_str(const char *sid, const char *att)
 604 {
 605         GKeyFile *kfile;
 606
 607         kfile = get_sensor_key_file();
 608         return g_key_file_get_string(kfile, sid, att, NULL);
 609 }
 610
 611 static bool sensor_get_bool(const char *sid, const char *att)
 612 {
 613         GKeyFile *kfile;
 614
 615         kfile = get_sensor_key_file();
 616         return g_key_file_get_boolean(kfile, sid, att, NULL);
 617 }
 618
 619 static void sensor_set_bool(const char *sid, const char *att, bool enabled)
 620 {
 621         GKeyFile *kfile;
 622
 623         kfile = get_sensor_key_file();
 624
 625         g_key_file_set_boolean(kfile, sid, att, enabled);
 626 }
 627
 628 static int sensor_get_int(const char *sid, const char *att)
 629 {
 630         GKeyFile *kfile;
 631
 632         kfile = get_sensor_key_file();
 633         return g_key_file_get_integer(kfile, sid, att, NULL);
 634 }
 635
 636 static void sensor_set_int(const char *sid, const char *att, int i)
 637 {
 638         GKeyFile *kfile;
 639
 640         kfile = get_sensor_key_file();
 641
 642         g_key_file_set_integer(kfile, sid, att, i);
 643 }
 644
 645 char *config_get_sensor_name(const char *sid)
 646 {
 647         return sensor_get_str(sid, ATT_SENSOR_NAME);
 648 }
 649
 650 void config_set_sensor_name(const char *sid, const char *name)
 651 {
 652         sensor_set_str(sid, ATT_SENSOR_NAME, name);
 653 }
 654
 655 void config_set_sensor_color(const char *sid, const GdkRGBA *color)
 656 {
 657         gchar *str;
 658
 659         str = gdk_rgba_to_string(color);
 660
 661         sensor_set_str(sid, ATT_SENSOR_COLOR, str);
 662
 663         g_free(str);
 664 }
 665
 666 static const char *next_default_color(void)
 667 {
 668         /* copied from the default colors of the gtk color color
 669          * chooser. */
 670         const char *default_colors[27] = {
 671                 "#ef2929",  /* Scarlet Red */
 672                 "#fcaf3e",  /* Orange */
 673                 "#fce94f",  /* Butter */
 674                 "#8ae234",  /* Chameleon */
 675                 "#729fcf",  /* Sky Blue */
 676                 "#ad7fa8",  /* Plum */
 677                 "#e9b96e",  /* Chocolate */
 678                 "#888a85",  /* Aluminum 1 */
 679                 "#eeeeec",  /* Aluminum 2 */
 680                 "#cc0000",
 681                 "#f57900",
 682                 "#edd400",
 683                 "#73d216",
 684                 "#3465a4",
 685                 "#75507b",
 686                 "#c17d11",
 687                 "#555753",
 688                 "#d3d7cf",
 689                 "#a40000",
 690                 "#ce5c00",
 691                 "#c4a000",
 692                 "#4e9a06",
 693                 "#204a87",
 694                 "#5c3566",
 695                 "#8f5902",
 696                 "#2e3436",
 697                 "#babdb6"
 698         };
 699         static int next_idx;
 700         const char *c;
 701
 702         c = default_colors[next_idx % 27];
 703
 704         next_idx++;
 705
 706         return c;
 707 }
 708
 709 GdkRGBA *config_get_sensor_color(const char *sid)
 710 {
 711         GdkRGBA rgba;
 712         char *str;
 713         gboolean ret;
 714
 715         str = sensor_get_str(sid, ATT_SENSOR_COLOR);
 716
 717         if (str) {
 718                 ret = gdk_rgba_parse(&rgba, str);
 719                 free(str);
 720         }
 721
 722         if (!str || !ret) {
 723                 gdk_rgba_parse(&rgba, next_default_color());
 724                 config_set_sensor_color(sid, &rgba);
 725         }
 726
 727         return gdk_rgba_copy(&rgba);
 728 }
 729
 730 bool config_is_sensor_graph_enabled(const char *sid)
 731 {
 732         return sensor_get_bool(sid, ATT_SENSOR_GRAPH_ENABLED);
 733 }
 734
 735 void config_set_sensor_graph_enabled(const char *sid, bool enabled)
 736 {
 737         sensor_set_bool(sid, ATT_SENSOR_GRAPH_ENABLED, enabled);
 738 }
 739
 740 int config_get_sensor_alarm_high_threshold(const char *sid)
 741 {
 742         return sensor_get_int(sid, ATT_SENSOR_ALARM_HIGH_THRESHOLD);
 743 }
 744
 745 void config_set_sensor_alarm_high_threshold(const char *sid, int threshold)
 746 {
 747         sensor_set_int(sid, ATT_SENSOR_ALARM_HIGH_THRESHOLD, threshold);
 748 }
 749
 750 int config_get_sensor_alarm_low_threshold(const char *sid)
 751 {
 752         return sensor_get_int(sid, ATT_SENSOR_ALARM_LOW_THRESHOLD);
 753 }
 754
 755 void config_set_sensor_alarm_low_threshold(const char *sid, int threshold)
 756 {
 757         sensor_set_int(sid, ATT_SENSOR_ALARM_LOW_THRESHOLD, threshold);
 758 }
 759
 760 bool config_is_appindicator_enabled(const char *sid)
 761 {
 762         return !sensor_get_bool(sid, ATT_SENSOR_APPINDICATOR_MENU_DISABLED);
 763 }
 764
 765 void config_set_appindicator_enabled(const char *sid, bool enabled)
 766 {
 767         sensor_set_bool(sid,
 768                         ATT_SENSOR_APPINDICATOR_MENU_DISABLED,
 769                         !enabled);
 770 }
 771
 772 int config_get_sensor_position(const char *sid)
 773 {
 774         return sensor_get_int(sid, ATT_SENSOR_POSITION);
 775 }
 776
 777 void config_set_sensor_position(const char *sid, int pos)
 778 {
 779         sensor_set_int(sid, ATT_SENSOR_POSITION, pos);
 780 }
 781
 782 bool config_get_sensor_alarm_enabled(const char *sid)
 783 {
 784         return sensor_get_bool(sid, ATT_SENSOR_ALARM_ENABLED);
 785 }
 786
 787 void config_set_sensor_alarm_enabled(const char *sid, bool enabled)
 788 {
 789         sensor_set_bool(sid, ATT_SENSOR_ALARM_ENABLED, enabled);
 790 }
 791
 792 bool config_is_sensor_enabled(const char *sid)
 793 {
 794         return !sensor_get_bool(sid, ATT_SENSOR_HIDE);
 795 }
 796
 797 void config_set_sensor_enabled(const char *sid, bool enabled)
 798 {
 799         sensor_set_bool(sid, ATT_SENSOR_HIDE, !enabled);
 800 }
 801
 802 bool config_is_appindicator_label_enabled(const char *sid)
 803 {
 804         return sensor_get_bool(sid, ATT_SENSOR_APPINDICATOR_LABEL_ENABLED);
 805 }
 806
 807 void config_set_appindicator_label_enabled(const char *sid, bool enabled)
 808 {
 809         sensor_set_bool(sid, ATT_SENSOR_APPINDICATOR_LABEL_ENABLED, enabled);
 810 }
 811
 812 GSettings *config_get_GSettings(void)
 813 {
 814         return settings;
 815 }
 816
 817 bool config_is_lmsensor_enabled(void)
 818 {
 819         return get_bool(KEY_PROVIDER_LMSENSORS_ENABLED);
 820 }
 821
 822 bool config_is_gtop2_enabled(void)
 823 {
 824         return get_bool(KEY_PROVIDER_GTOP2_ENABLED);
 825 }
 826
 827 bool config_is_udisks2_enabled(void)
 828 {
 829         return get_bool(KEY_PROVIDER_UDISKS2_ENABLED);
 830 }
 831
 832 bool config_is_hddtemp_enabled(void)
 833 {
 834         return get_bool(KEY_PROVIDER_HDDTEMP_ENABLED);
 835 }
 836
 837 bool config_is_libatasmart_enabled(void)
 838 {
 839         return get_bool(KEY_PROVIDER_LIBATASMART_ENABLED);
 840 }
 841
 842 bool config_is_nvctrl_enabled(void)
 843 {
 844         return get_bool(KEY_PROVIDER_NVCTRL_ENABLED);
 845 }
 846
 847 bool config_is_atiadlsdk_enabled(void)
 848 {
 849         return get_bool(KEY_PROVIDER_ATIADLSDK_ENABLED);
 850 }
 851
 852 void config_set_lmsensor_enable(bool b)
 853 {
 854         set_bool(KEY_PROVIDER_LMSENSORS_ENABLED, b);
 855 }
 856
 857 void config_set_nvctrl_enable(bool b)
 858 {
 859         set_bool(KEY_PROVIDER_NVCTRL_ENABLED, b);
 860 }
 861
 862 void config_set_atiadlsdk_enable(bool b)
 863 {
 864         set_bool(KEY_PROVIDER_ATIADLSDK_ENABLED, b);
 865 }
 866
 867 void config_set_gtop2_enable(bool b)
 868 {
 869         set_bool(KEY_PROVIDER_GTOP2_ENABLED, b);
 870 }
 871
 872 void config_set_hddtemp_enable(bool b)
 873 {
 874         set_bool(KEY_PROVIDER_HDDTEMP_ENABLED, b);
 875 }
 876
 877 void config_set_libatasmart_enable(bool b)
 878 {
 879         set_bool(KEY_PROVIDER_LIBATASMART_ENABLED, b);
 880 }
 881
 882 void config_set_udisks2_enable(bool b)
 883 {
 884         set_bool(KEY_PROVIDER_UDISKS2_ENABLED, b);
 885 }
 886
 887 int config_get_sensor_unit(void)
 888 {
 889         return get_int(KEY_INTERFACE_TEMPERATURE_UNIT);
 890 }