src/cfg.c

   1 /*
   2  * Copyright (C) 2010-2016 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 const char *KEY_DEFAULT_HIGH_THRESHOLD_TEMPERATURE
 123 = "default-high-threshold-temperature";
 124 static const char *KEY_DEFAULT_SENSOR_ALARM_ENABLED
 125 = "default-sensor-alarm-enabled";
 126
 127 static GSettings *settings;
 128
 129 static char *user_dir;
 130
 131 static GKeyFile *key_file;
 132
 133 static char *sensor_config_path;
 134
 135 static void (*slog_enabled_cbk)(void *);
 136
 137 static char *get_string(const char *key)
 138 {
 139         return g_settings_get_string(settings, key);
 140 }
 141
 142 static void set_string(const char *key, const char *str)
 143 {
 144         g_settings_set_string(settings, key, str);
 145 }
 146
 147 static void set_bool(const char *k, bool b)
 148 {
 149         g_settings_set_boolean(settings, k, b);
 150 }
 151
 152 static bool get_bool(const char *k)
 153 {
 154         return g_settings_get_boolean(settings, k);
 155 }
 156
 157 static void set_int(const char *k, int i)
 158 {
 159         g_settings_set_int(settings, k, i);
 160 }
 161
 162 static double get_double(const char *k)
 163 {
 164         return g_settings_get_double(settings, k);
 165 }
 166
 167 static void set_double(const char *k, double d)
 168 {
 169         g_settings_set_double(settings, k, d);
 170 }
 171
 172 static int get_int(const char *k)
 173 {
 174         return g_settings_get_int(settings, k);
 175 }
 176
 177 char *config_get_notif_script(void)
 178 {
 179         char *str;
 180
 181         str =  get_string(KEY_NOTIFICATION_SCRIPT);
 182         if (str && !strlen(str)) {
 183                 free(str);
 184                 str = NULL;
 185         }
 186
 187         return str;
 188 }
 189
 190 void config_set_notif_script(const char *str)
 191 {
 192         if (str && strlen(str) > 0)
 193                 set_string(KEY_NOTIFICATION_SCRIPT, str);
 194         else
 195                 set_string(KEY_NOTIFICATION_SCRIPT, "");
 196 }
 197
 198 static struct color *get_background_color(void)
 199 {
 200         char *scolor;
 201         struct color *c;
 202
 203         scolor = get_string(KEY_GRAPH_BACKGROUND_COLOR);
 204
 205         c = str_to_color(scolor);
 206         free(scolor);
 207
 208         if (!c)
 209                 return color_new(1, 1, 1);
 210
 211         return c;
 212 }
 213
 214 static struct color *get_foreground_color(void)
 215 {
 216         char *scolor;
 217         struct color *c;
 218
 219         scolor = get_string(KEY_GRAPH_FOREGROUND_COLOR);
 220
 221         c = str_to_color(scolor);
 222         free(scolor);
 223
 224         if (!c)
 225                 return color_new(0, 0, 0);
 226
 227         return c;
 228 }
 229
 230 static bool is_alpha_channel_enabled(void)
 231 {
 232         return get_bool(KEY_ALPHA_CHANNEL_ENABLED);
 233 }
 234
 235 static void set_alpha_channeld_enabled(bool b)
 236 {
 237         set_bool(KEY_ALPHA_CHANNEL_ENABLED, b);
 238 }
 239
 240 enum sensorlist_position config_get_sensorlist_position(void)
 241 {
 242         return get_int(KEY_INTERFACE_SENSORLIST_POSITION);
 243 }
 244
 245 void config_set_sensorlist_position(enum sensorlist_position pos)
 246 {
 247         set_int(KEY_INTERFACE_SENSORLIST_POSITION, pos);
 248 }
 249
 250 static double get_graph_background_alpha(void)
 251 {
 252         return get_double(KEY_GRAPH_BACKGROUND_ALPHA);
 253 }
 254
 255 static void set_graph_background_alpha(double alpha)
 256 {
 257         set_double(KEY_GRAPH_BACKGROUND_ALPHA, alpha);
 258 }
 259
 260 static void set_background_color(const struct color *color)
 261 {
 262         char *scolor;
 263
 264         scolor = color_to_str(color);
 265         if (!scolor)
 266                 scolor = strdup(DEFAULT_GRAPH_BACKGROUND_COLOR);
 267
 268         set_string(KEY_GRAPH_BACKGROUND_COLOR, scolor);
 269
 270         free(scolor);
 271 }
 272
 273 static void set_foreground_color(const struct color *color)
 274 {
 275         char *str;
 276
 277         str = color_to_str(color);
 278         if (!str)
 279                 str = strdup(DEFAULT_GRAPH_FOREGROUND_COLOR);
 280
 281         set_string(KEY_GRAPH_FOREGROUND_COLOR, str);
 282
 283         free(str);
 284 }
 285
 286 bool is_slog_enabled(void)
 287 {
 288         return get_bool(KEY_SLOG_ENABLED);
 289 }
 290
 291 static void set_slog_enabled(bool enabled)
 292 {
 293         set_bool(KEY_SLOG_ENABLED, enabled);
 294 }
 295
 296 static void slog_enabled_changed_cbk(GSettings *settings,
 297                                      gchar *key,
 298                                      gpointer data)
 299 {
 300         if (slog_enabled_cbk)
 301                 slog_enabled_cbk(data);
 302 }
 303
 304 void config_set_slog_enabled_changed_cbk(void (*cbk)(void *), void *data)
 305 {
 306         log_fct_enter();
 307
 308         slog_enabled_cbk = cbk;
 309
 310         g_signal_connect_after(settings,
 311                                "changed::slog-enabled",
 312                                G_CALLBACK(slog_enabled_changed_cbk),
 313                                data);
 314
 315         log_fct_exit();
 316 }
 317
 318 int config_get_slog_interval(void)
 319 {
 320         return get_int(KEY_SLOG_INTERVAL);
 321 }
 322
 323 static void set_slog_interval(int interval)
 324 {
 325         if (interval <= 0)
 326                 interval = 300;
 327
 328         set_int(KEY_SLOG_INTERVAL, interval);
 329 }
 330
 331 bool config_is_window_decoration_enabled(void)
 332 {
 333         return !get_bool(KEY_INTERFACE_WINDOW_DECORATION_DISABLED);
 334 }
 335
 336 bool config_is_window_keep_below_enabled(void)
 337 {
 338         return get_bool(KEY_INTERFACE_WINDOW_KEEP_BELOW_ENABLED);
 339 }
 340
 341 void config_set_window_decoration_enabled(bool enabled)
 342 {
 343         set_bool(KEY_INTERFACE_WINDOW_DECORATION_DISABLED, !enabled);
 344 }
 345
 346 void config_set_window_keep_below_enabled(bool enabled)
 347 {
 348         set_bool(KEY_INTERFACE_WINDOW_KEEP_BELOW_ENABLED, enabled);
 349 }
 350
 351 bool config_is_smooth_curves_enabled(void)
 352 {
 353         return get_bool(KEY_GRAPH_SMOOTH_CURVES_ENABLED);
 354 }
 355
 356 void config_set_smooth_curves_enabled(bool b)
 357 {
 358         set_bool(KEY_GRAPH_SMOOTH_CURVES_ENABLED, b);
 359 }
 360
 361 double config_get_default_high_threshold_temperature(void)
 362 {
 363         return get_double(KEY_DEFAULT_HIGH_THRESHOLD_TEMPERATURE);
 364 }
 365
 366 static bool config_get_default_sensor_alarm_enabled(void)
 367 {
 368         return get_bool(KEY_DEFAULT_SENSOR_ALARM_ENABLED);
 369 }
 370
 371 static void init(void)
 372 {
 373         log_fct_enter();
 374
 375         if (!settings)
 376                 settings = g_settings_new("psensor");
 377
 378         log_fct_exit();
 379 }
 380
 381 void config_cleanup(void)
 382 {
 383         config_sync();
 384
 385         if (settings) {
 386                 g_settings_sync();
 387                 g_object_unref(settings);
 388                 settings = NULL;
 389         }
 390
 391         if (user_dir) {
 392                 free(user_dir);
 393                 user_dir = NULL;
 394         }
 395
 396         if (key_file) {
 397                 g_key_file_free(key_file);
 398                 key_file = NULL;
 399         }
 400
 401         if (sensor_config_path) {
 402                 free(sensor_config_path);
 403                 sensor_config_path = NULL;
 404         }
 405
 406         slog_enabled_cbk = NULL;
 407 }
 408
 409 struct config *config_load(void)
 410 {
 411         struct config *c;
 412
 413         init();
 414
 415         c = malloc(sizeof(struct config));
 416
 417         c->graph_bgcolor = get_background_color();
 418         c->graph_fgcolor = get_foreground_color();
 419         c->graph_bg_alpha = get_graph_background_alpha();
 420         c->alpha_channel_enabled = is_alpha_channel_enabled();
 421         c->slog_enabled = is_slog_enabled();
 422         c->slog_interval = config_get_slog_interval();
 423
 424         c->sensor_update_interval
 425             = get_int(KEY_SENSOR_UPDATE_INTERVAL);
 426         if (c->sensor_update_interval < 1)
 427                 c->sensor_update_interval = 1;
 428
 429         c->graph_update_interval = get_int(KEY_GRAPH_UPDATE_INTERVAL);
 430         if (c->graph_update_interval < 1)
 431                 c->graph_update_interval = 1;
 432
 433         c->graph_monitoring_duration = get_int(KEY_GRAPH_MONITORING_DURATION);
 434
 435         if (c->graph_monitoring_duration < 1)
 436                 c->graph_monitoring_duration = 10;
 437
 438         c->window_restore_enabled
 439                 = get_bool(KEY_INTERFACE_WINDOW_RESTORE_ENABLED);
 440
 441         c->window_x = get_int(KEY_INTERFACE_WINDOW_X);
 442         c->window_y = get_int(KEY_INTERFACE_WINDOW_Y);
 443         c->window_w = get_int(KEY_INTERFACE_WINDOW_W);
 444         c->window_h = get_int(KEY_INTERFACE_WINDOW_H);
 445
 446         c->window_divider_pos = get_int(KEY_INTERFACE_WINDOW_DIVIDER_POS);
 447
 448         c->hide_on_startup = get_bool(KEY_INTERFACE_HIDE_ON_STARTUP);
 449
 450         if (!c->window_restore_enabled || !c->window_w || !c->window_h) {
 451                 c->window_w = 800;
 452                 c->window_h = 200;
 453         }
 454
 455         c->sensor_values_max_length = compute_values_max_length(c);
 456
 457         return c;
 458 }
 459
 460 void config_save(const struct config *c)
 461 {
 462         set_alpha_channeld_enabled(c->alpha_channel_enabled);
 463         set_background_color(c->graph_bgcolor);
 464         set_foreground_color(c->graph_fgcolor);
 465         set_graph_background_alpha(c->graph_bg_alpha);
 466         set_slog_enabled(c->slog_enabled);
 467         set_slog_interval(c->slog_interval);
 468
 469         set_int(KEY_GRAPH_UPDATE_INTERVAL, c->graph_update_interval);
 470
 471         set_int(KEY_GRAPH_MONITORING_DURATION, c->graph_monitoring_duration);
 472
 473         set_int(KEY_SENSOR_UPDATE_INTERVAL, c->sensor_update_interval);
 474
 475         set_bool(KEY_INTERFACE_HIDE_ON_STARTUP, c->hide_on_startup);
 476
 477         set_bool(KEY_INTERFACE_WINDOW_RESTORE_ENABLED,
 478                  c->window_restore_enabled);
 479
 480         set_int(KEY_INTERFACE_WINDOW_X, c->window_x);
 481         set_int(KEY_INTERFACE_WINDOW_Y, c->window_y);
 482         set_int(KEY_INTERFACE_WINDOW_W, c->window_w);
 483         set_int(KEY_INTERFACE_WINDOW_H, c->window_h);
 484
 485         set_int(KEY_INTERFACE_WINDOW_DIVIDER_POS, c->window_divider_pos);
 486 }
 487
 488 const char *get_psensor_user_dir(void)
 489 {
 490         const char *home;
 491
 492         log_fct_enter();
 493
 494         if (!user_dir) {
 495                 home = getenv("HOME");
 496
 497                 if (!home)
 498                         return NULL;
 499
 500                 user_dir = path_append(home, ".psensor");
 501
 502                 if (mkdir(user_dir, 0700) == -1 && errno != EEXIST) {
 503                         log_err(_("Failed to create the directory %s: %s"),
 504                                 user_dir,
 505                                 strerror(errno));
 506
 507                         free(user_dir);
 508                         user_dir = NULL;
 509                 }
 510         }
 511
 512         log_fct_exit();
 513
 514         return user_dir;
 515 }
 516
 517 static const char *get_sensor_config_path(void)
 518 {
 519         const char *dir;
 520
 521         if (!sensor_config_path) {
 522                 dir = get_psensor_user_dir();
 523
 524                 if (dir)
 525                         sensor_config_path = path_append(dir, "psensor.cfg");
 526         }
 527
 528         return sensor_config_path;
 529 }
 530
 531 static GKeyFile *get_sensor_key_file(void)
 532 {
 533         int ret;
 534         GError *err;
 535         const char *path;
 536
 537         if (!key_file) {
 538                 path = get_sensor_config_path();
 539
 540                 key_file = g_key_file_new();
 541
 542                 err = NULL;
 543                 ret = g_key_file_load_from_file(key_file,
 544                                                 path,
 545                                                 G_KEY_FILE_KEEP_COMMENTS
 546                                                 | G_KEY_FILE_KEEP_TRANSLATIONS,
 547                                                 &err);
 548
 549                 if (!ret) {
 550                         log_warn(_("Failed to load configuration file %s: %s"),
 551                                  path,
 552                                  err->message);
 553                         g_error_free(err);
 554                 }
 555         }
 556
 557         return key_file;
 558 }
 559
 560 static void save_sensor_key_file(void)
 561 {
 562         GKeyFile *kfile;
 563         const char *path;
 564         char *data;
 565
 566         log_fct_enter();
 567
 568         kfile = get_sensor_key_file();
 569
 570         data = g_key_file_to_data(kfile, NULL, NULL);
 571
 572         path = get_sensor_config_path();
 573
 574         if (!g_file_set_contents(path, data, -1, NULL))
 575                 log_err(_("Failed to save configuration file %s."), path);
 576
 577         free(data);
 578
 579         log_fct_exit();
 580 }
 581
 582 void config_sync(void)
 583 {
 584         log_fct_enter();
 585         if (settings)
 586                 g_settings_sync();
 587         save_sensor_key_file();
 588         log_fct_exit();
 589 }
 590
 591 static void sensor_set_str(const char *sid, const char *att, const char *str)
 592 {
 593         GKeyFile *kfile;
 594
 595         kfile = get_sensor_key_file();
 596         g_key_file_set_string(kfile, sid, att, str);
 597 }
 598
 599 static char *sensor_get_str(const char *sid, const char *att)
 600 {
 601         GKeyFile *kfile;
 602
 603         kfile = get_sensor_key_file();
 604         return g_key_file_get_string(kfile, sid, att, NULL);
 605 }
 606
 607 static bool sensor_get_double(const char *sid,
 608                               const char *att,
 609                               double *d,
 610                               double d_default)
 611 {
 612         GKeyFile *kfile;
 613         GError *err;
 614         double v;
 615
 616         kfile = get_sensor_key_file();
 617
 618         err = NULL;
 619         if (!g_key_file_has_key(kfile, sid, att, &err)) {
 620                 if (err) {
 621                         log_err(err->message);
 622                         g_error_free(err);
 623                         return false;
 624                 }
 625
 626                 *d = d_default;
 627                 return true;
 628         }
 629
 630         err = NULL;
 631         v = g_key_file_get_double(kfile, sid, att, &err);
 632
 633         if (err) {
 634                 log_err(err->message);
 635
 636                 g_error_free(err);
 637
 638                 return false;
 639         }
 640
 641         *d = v;
 642         return true;
 643 }
 644
 645 static bool sensor_get_bool(const char *sid, const char *att, bool dft)
 646 {
 647         GKeyFile *kfile;
 648         GError *err;
 649         bool ret;
 650
 651         kfile = get_sensor_key_file();
 652
 653         err = NULL;
 654         ret = g_key_file_get_boolean(kfile, sid, att, &err);
 655
 656         if (err) {
 657                 if (err->code == G_KEY_FILE_ERROR_KEY_NOT_FOUND)
 658                         ret = dft;
 659                 else
 660                         log_err(err->message);
 661
 662                 g_error_free(err);
 663         }
 664
 665         return ret;
 666 }
 667
 668 static void sensor_set_bool(const char *sid, const char *att, bool enabled)
 669 {
 670         GKeyFile *kfile;
 671
 672         kfile = get_sensor_key_file();
 673
 674         g_key_file_set_boolean(kfile, sid, att, enabled);
 675 }
 676
 677 static int sensor_get_int(const char *sid, const char *att)
 678 {
 679         GKeyFile *kfile;
 680
 681         kfile = get_sensor_key_file();
 682         return g_key_file_get_integer(kfile, sid, att, NULL);
 683 }
 684
 685 static void sensor_set_int(const char *sid, const char *att, int i)
 686 {
 687         GKeyFile *kfile;
 688
 689         kfile = get_sensor_key_file();
 690
 691         g_key_file_set_integer(kfile, sid, att, i);
 692 }
 693
 694 char *config_get_sensor_name(const char *sid)
 695 {
 696         return sensor_get_str(sid, ATT_SENSOR_NAME);
 697 }
 698
 699 void config_set_sensor_name(const char *sid, const char *name)
 700 {
 701         sensor_set_str(sid, ATT_SENSOR_NAME, name);
 702 }
 703
 704 void config_set_sensor_color(const char *sid, const GdkRGBA *color)
 705 {
 706         gchar *str;
 707
 708         str = gdk_rgba_to_string(color);
 709
 710         sensor_set_str(sid, ATT_SENSOR_COLOR, str);
 711
 712         g_free(str);
 713 }
 714
 715 static const char *next_default_color(void)
 716 {
 717         /* copied from the default colors of the gtk color color
 718          * chooser.
 719          */
 720         const char *default_colors[27] = {
 721                 "#ef2929",  /* Scarlet Red */
 722                 "#fcaf3e",  /* Orange */
 723                 "#fce94f",  /* Butter */
 724                 "#8ae234",  /* Chameleon */
 725                 "#729fcf",  /* Sky Blue */
 726                 "#ad7fa8",  /* Plum */
 727                 "#e9b96e",  /* Chocolate */
 728                 "#888a85",  /* Aluminum 1 */
 729                 "#eeeeec",  /* Aluminum 2 */
 730                 "#cc0000",
 731                 "#f57900",
 732                 "#edd400",
 733                 "#73d216",
 734                 "#3465a4",
 735                 "#75507b",
 736                 "#c17d11",
 737                 "#555753",
 738                 "#d3d7cf",
 739                 "#a40000",
 740                 "#ce5c00",
 741                 "#c4a000",
 742                 "#4e9a06",
 743                 "#204a87",
 744                 "#5c3566",
 745                 "#8f5902",
 746                 "#2e3436",
 747                 "#babdb6"
 748         };
 749         static int next_idx;
 750         const char *c;
 751
 752         c = default_colors[next_idx % 27];
 753
 754         next_idx++;
 755
 756         return c;
 757 }
 758
 759 GdkRGBA *config_get_sensor_color(const char *sid)
 760 {
 761         GdkRGBA rgba;
 762         char *str;
 763         gboolean ret;
 764
 765         str = sensor_get_str(sid, ATT_SENSOR_COLOR);
 766
 767         if (str) {
 768                 ret = gdk_rgba_parse(&rgba, str);
 769                 free(str);
 770         }
 771
 772         if (!str || !ret) {
 773                 gdk_rgba_parse(&rgba, next_default_color());
 774                 config_set_sensor_color(sid, &rgba);
 775         }
 776
 777         return gdk_rgba_copy(&rgba);
 778 }
 779
 780 bool config_is_sensor_graph_enabled(const char *sid)
 781 {
 782         return sensor_get_bool(sid, ATT_SENSOR_GRAPH_ENABLED, false);
 783 }
 784
 785 void config_set_sensor_graph_enabled(const char *sid, bool enabled)
 786 {
 787         sensor_set_bool(sid, ATT_SENSOR_GRAPH_ENABLED, enabled);
 788 }
 789
 790 bool config_get_sensor_alarm_high_threshold(const char *sid,
 791                                             double *v,
 792                                             double d)
 793 {
 794         return sensor_get_double(sid, ATT_SENSOR_ALARM_HIGH_THRESHOLD, v, d);
 795 }
 796
 797 void config_set_sensor_alarm_high_threshold(const char *sid, int threshold)
 798 {
 799         sensor_set_int(sid, ATT_SENSOR_ALARM_HIGH_THRESHOLD, threshold);
 800 }
 801
 802 bool config_get_sensor_alarm_low_threshold(const char *sid, double *v, double d)
 803 {
 804         return sensor_get_double(sid, ATT_SENSOR_ALARM_LOW_THRESHOLD, v, d);
 805 }
 806
 807 void config_set_sensor_alarm_low_threshold(const char *sid, int threshold)
 808 {
 809         sensor_set_int(sid, ATT_SENSOR_ALARM_LOW_THRESHOLD, threshold);
 810 }
 811
 812 bool config_is_appindicator_enabled(const char *sid)
 813 {
 814         return !sensor_get_bool(sid,
 815                                 ATT_SENSOR_APPINDICATOR_MENU_DISABLED,
 816                                 false);
 817 }
 818
 819 void config_set_appindicator_enabled(const char *sid, bool enabled)
 820 {
 821         sensor_set_bool(sid,
 822                         ATT_SENSOR_APPINDICATOR_MENU_DISABLED,
 823                         !enabled);
 824 }
 825
 826 int config_get_sensor_position(const char *sid)
 827 {
 828         return sensor_get_int(sid, ATT_SENSOR_POSITION);
 829 }
 830
 831 void config_set_sensor_position(const char *sid, int pos)
 832 {
 833         sensor_set_int(sid, ATT_SENSOR_POSITION, pos);
 834 }
 835
 836 bool config_get_sensor_alarm_enabled(const char *sid)
 837 {
 838         return sensor_get_bool(sid, ATT_SENSOR_ALARM_ENABLED, false);
 839 }
 840
 841 void config_set_sensor_alarm_enabled(const char *sid, bool enabled)
 842 {
 843         sensor_set_bool(sid, ATT_SENSOR_ALARM_ENABLED, enabled);
 844 }
 845
 846 bool config_is_sensor_enabled(const char *sid)
 847 {
 848         return !sensor_get_bool(sid,
 849                                 ATT_SENSOR_HIDE,
 850                                 config_get_default_sensor_alarm_enabled());
 851 }
 852
 853 void config_set_sensor_enabled(const char *sid, bool enabled)
 854 {
 855         sensor_set_bool(sid, ATT_SENSOR_HIDE, !enabled);
 856 }
 857
 858 bool config_is_appindicator_label_enabled(const char *sid)
 859 {
 860         return sensor_get_bool(sid,
 861                                ATT_SENSOR_APPINDICATOR_LABEL_ENABLED,
 862                                false);
 863 }
 864
 865 void config_set_appindicator_label_enabled(const char *sid, bool enabled)
 866 {
 867         sensor_set_bool(sid, ATT_SENSOR_APPINDICATOR_LABEL_ENABLED, enabled);
 868 }
 869
 870 GSettings *config_get_GSettings(void)
 871 {
 872         return settings;
 873 }
 874
 875 bool config_is_lmsensor_enabled(void)
 876 {
 877         return get_bool(KEY_PROVIDER_LMSENSORS_ENABLED);
 878 }
 879
 880 bool config_is_gtop2_enabled(void)
 881 {
 882         return get_bool(KEY_PROVIDER_GTOP2_ENABLED);
 883 }
 884
 885 bool config_is_udisks2_enabled(void)
 886 {
 887         return get_bool(KEY_PROVIDER_UDISKS2_ENABLED);
 888 }
 889
 890 bool config_is_hddtemp_enabled(void)
 891 {
 892         return get_bool(KEY_PROVIDER_HDDTEMP_ENABLED);
 893 }
 894
 895 bool config_is_libatasmart_enabled(void)
 896 {
 897         return get_bool(KEY_PROVIDER_LIBATASMART_ENABLED);
 898 }
 899
 900 bool config_is_nvctrl_enabled(void)
 901 {
 902         return get_bool(KEY_PROVIDER_NVCTRL_ENABLED);
 903 }
 904
 905 bool config_is_atiadlsdk_enabled(void)
 906 {
 907         return get_bool(KEY_PROVIDER_ATIADLSDK_ENABLED);
 908 }
 909
 910 void config_set_lmsensor_enable(bool b)
 911 {
 912         set_bool(KEY_PROVIDER_LMSENSORS_ENABLED, b);
 913 }
 914
 915 void config_set_nvctrl_enable(bool b)
 916 {
 917         set_bool(KEY_PROVIDER_NVCTRL_ENABLED, b);
 918 }
 919
 920 void config_set_atiadlsdk_enable(bool b)
 921 {
 922         set_bool(KEY_PROVIDER_ATIADLSDK_ENABLED, b);
 923 }
 924
 925 void config_set_gtop2_enable(bool b)
 926 {
 927         set_bool(KEY_PROVIDER_GTOP2_ENABLED, b);
 928 }
 929
 930 void config_set_hddtemp_enable(bool b)
 931 {
 932         set_bool(KEY_PROVIDER_HDDTEMP_ENABLED, b);
 933 }
 934
 935 void config_set_libatasmart_enable(bool b)
 936 {
 937         set_bool(KEY_PROVIDER_LIBATASMART_ENABLED, b);
 938 }
 939
 940 void config_set_udisks2_enable(bool b)
 941 {
 942         set_bool(KEY_PROVIDER_UDISKS2_ENABLED, b);
 943 }
 944
 945 enum temperature_unit config_get_temperature_unit(void)
 946 {
 947         return get_int(KEY_INTERFACE_TEMPERATURE_UNIT);
 948 }
 949
 950 void config_set_temperature_unit(enum temperature_unit u)
 951 {
 952         set_int(KEY_INTERFACE_TEMPERATURE_UNIT, u);
 953 }
 954
 955 bool config_is_menu_bar_enabled(void)
 956 {
 957         return !get_bool(KEY_INTERFACE_MENU_BAR_DISABLED);
 958 }
 959
 960 void config_set_menu_bar_enabled(bool enabled)
 961 {
 962         set_bool(KEY_INTERFACE_MENU_BAR_DISABLED, !enabled);
 963 }
 964
 965 bool config_is_count_visible(void)
 966 {
 967         return !get_bool(KEY_INTERFACE_UNITY_LAUNCHER_COUNT_DISABLED);
 968 }
 969
 970 void config_set_count_visible(bool visible)
 971 {
 972         set_bool(KEY_INTERFACE_UNITY_LAUNCHER_COUNT_DISABLED, !visible);
 973 }