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 #include <stdlib.h>
  20 #include <stdio.h>
  21 #include <string.h>
  22 #include <ctype.h>
  23
  24 #include "cfg.h"
  25 #include "log.h"
  26
  27 static const char *KEY_SENSORS = "/apps/psensor/sensors";
  28
  29 static const char *ATT_SENSOR_ALARM_ENABLED = "alarm/enabled";
  30 static const char *ATT_SENSOR_ALARM_HIGH_THRESHOLD = "alarm/high_threshold";
  31 static const char *ATT_SENSOR_ALARM_LOW_THRESHOLD = "alarm/low_threshold";
  32 static const char *ATT_SENSOR_COLOR = "color";
  33 static const char *ATT_SENSOR_ENABLED = "enabled";
  34 static const char *ATT_SENSOR_NAME = "name";
  35 static const char *ATT_SENSOR_APPINDICATOR_DISABLED = "appindicator/disabled";
  36 static const char *ATT_SENSOR_POSITION = "position";
  37
  38 static const char *KEY_SENSOR_UPDATE_INTERVAL
  39 = "/apps/psensor/sensor/update_interval";
  40
  41 static const char *KEY_GRAPH_UPDATE_INTERVAL
  42 = "/apps/psensor/graph/update_interval";
  43
  44 static const char *KEY_GRAPH_MONITORING_DURATION
  45 = "/apps/psensor/graph/monitoring_duration";
  46
  47 static const char *KEY_GRAPH_BACKGROUND_COLOR
  48 = "/apps/psensor/graph/background_color";
  49
  50 static const char *DEFAULT_GRAPH_BACKGROUND_COLOR = "#e8f4e8f4a8f5";
  51
  52 static const char *KEY_GRAPH_BACKGROUND_ALPHA
  53 = "/apps/psensor/graph/background_alpha";
  54
  55 static const char *KEY_GRAPH_FOREGROUND_COLOR
  56 = "/apps/psensor/graph/foreground_color";
  57 static const char *DEFAULT_GRAPH_FOREGROUND_COLOR = "#000000000000";
  58
  59 static const char *KEY_ALPHA_CHANNEL_ENABLED
  60 = "/apps/psensor/graph/alpha_channel_enabled";
  61
  62 static const char *KEY_INTERFACE_SENSORLIST_POSITION
  63 = "/apps/psensor/interface/sensorlist_position";
  64
  65 static const char *KEY_INTERFACE_WINDOW_DECORATION_DISABLED
  66 = "/apps/psensor/interface/window_decoration_disabled";
  67
  68 static const char *KEY_INTERFACE_WINDOW_KEEP_BELOW_ENABLED
  69 = "/apps/psensor/interface/window_keep_below_enabled";
  70
  71 static const char *KEY_INTERFACE_MENU_BAR_DISABLED
  72 = "/apps/psensor/interface/menu_bar_disabled";
  73
  74 static const char *KEY_INTERFACE_UNITY_LAUNCHER_COUNT_DISABLED
  75 = "/apps/psensor/interface/unity_launcher_count_disabled";
  76
  77 static const char *KEY_INTERFACE_HIDE_ON_STARTUP
  78 = "/apps/psensor/interface/hide_on_startup";
  79
  80 static const char *KEY_INTERFACE_WINDOW_RESTORE_ENABLED
  81 = "/apps/psensor/interface/window_restore_enabled";
  82
  83 static const char *KEY_INTERFACE_WINDOW_X = "/apps/psensor/interface/window_x";
  84 static const char *KEY_INTERFACE_WINDOW_Y = "/apps/psensor/interface/window_y";
  85 static const char *KEY_INTERFACE_WINDOW_W = "/apps/psensor/interface/window_w";
  86 static const char *KEY_INTERFACE_WINDOW_H = "/apps/psensor/interface/window_h";
  87
  88 static const char *KEY_INTERFACE_WINDOW_DIVIDER_POS
  89 = "/apps/psensor/interface/window_divider_pos";
  90
  91 static const char *KEY_INTERFACE_TEMPERATURE_UNIT
  92 = "/apps/psensor/interface/temperature_unit";
  93
  94 static const char *KEY_SLOG_ENABLED = "/apps/psensor/slog/enabled";
  95 static const char *KEY_SLOG_INTERVAL = "/apps/psensor/slog/interval";
  96
  97 static const char *KEY_NOTIFICATION_SCRIPT = "/apps/psensor/notif_script";
  98
  99 static GConfClient *client;
 100
 101 static char *get_string(const char *key, const char *default_value)
 102 {
 103         char *value;
 104
 105         value = gconf_client_get_string(client, key, NULL);
 106
 107         if (!value) {
 108                 value = strdup(default_value);
 109                 gconf_client_set_string(client, key, default_value, NULL);
 110         }
 111
 112         return value;
 113 }
 114
 115 char *config_get_notif_script()
 116 {
 117         char *str;
 118
 119         str =  gconf_client_get_string(client, KEY_NOTIFICATION_SCRIPT, NULL);
 120         if (str && !strlen(str)) {
 121                 free(str);
 122                 str = NULL;
 123         }
 124
 125         return str;
 126 }
 127
 128 void config_set_notif_script(const char *str)
 129 {
 130         if (str && strlen(str) > 0)
 131                 gconf_client_set_string(client,
 132                                         KEY_NOTIFICATION_SCRIPT, str, NULL);
 133         else
 134                 gconf_client_set_string(client,
 135                                         KEY_NOTIFICATION_SCRIPT, "", NULL);
 136 }
 137
 138 static struct color *get_background_color()
 139 {
 140         char *scolor;
 141         struct color *c;
 142
 143         scolor = get_string(KEY_GRAPH_BACKGROUND_COLOR,
 144                             DEFAULT_GRAPH_BACKGROUND_COLOR);
 145
 146         c = str_to_color(scolor);
 147         free(scolor);
 148
 149         if (!c)
 150                 return color_new(0xffff, 0xffff, 0xffff);
 151
 152         return c;
 153 }
 154
 155 static struct color *get_foreground_color()
 156 {
 157         char *scolor;
 158         struct color *c;
 159
 160         scolor = get_string(KEY_GRAPH_FOREGROUND_COLOR,
 161                             DEFAULT_GRAPH_FOREGROUND_COLOR);
 162
 163         c = str_to_color(scolor);
 164         free(scolor);
 165
 166         if (!c)
 167                 return color_new(0x0000, 0x0000, 0x0000);
 168
 169         return c;
 170 }
 171
 172 static bool is_alpha_channel_enabled()
 173 {
 174         return gconf_client_get_bool(client, KEY_ALPHA_CHANNEL_ENABLED, NULL);
 175 }
 176
 177 static enum sensorlist_position get_sensorlist_position()
 178 {
 179         return gconf_client_get_int(client,
 180                                     KEY_INTERFACE_SENSORLIST_POSITION, NULL);
 181 }
 182
 183 static void set_sensorlist_position(enum sensorlist_position pos)
 184 {
 185         gconf_client_set_int(client,
 186                              KEY_INTERFACE_SENSORLIST_POSITION, pos, NULL);
 187 }
 188
 189 static double get_graph_background_alpha()
 190 {
 191         double a;
 192
 193         a = gconf_client_get_float(client, KEY_GRAPH_BACKGROUND_ALPHA, NULL);
 194         if (a == 0)
 195                 gconf_client_set_float(client,
 196                                        KEY_GRAPH_BACKGROUND_ALPHA, 1.0, NULL);
 197         return a;
 198 }
 199
 200 static void set_graph_background_alpha(double alpha)
 201 {
 202         gconf_client_set_float(client, KEY_GRAPH_BACKGROUND_ALPHA, alpha, NULL);
 203 }
 204
 205 static void set_background_color(const struct color *color)
 206 {
 207         char *scolor;
 208
 209         scolor = color_to_str(color);
 210         if (!scolor)
 211                 scolor = strdup(DEFAULT_GRAPH_BACKGROUND_COLOR);
 212
 213         gconf_client_set_string(client,
 214                                 KEY_GRAPH_BACKGROUND_COLOR, scolor, NULL);
 215
 216         free(scolor);
 217 }
 218
 219 static void set_foreground_color(const struct color *color)
 220 {
 221         char *str;
 222
 223         str = color_to_str(color);
 224         if (!str)
 225                 str = strdup(DEFAULT_GRAPH_FOREGROUND_COLOR);
 226
 227         gconf_client_set_string(client, KEY_GRAPH_FOREGROUND_COLOR, str, NULL);
 228
 229         free(str);
 230 }
 231
 232 static char *get_sensor_att_key(const char *sid, const char *att)
 233 {
 234         char *esc_sid, *key;
 235
 236         esc_sid = gconf_escape_key(sid, -1);
 237         /* [KEY_SENSORS]/[esc_sid]/[att] */
 238         key = malloc(strlen(KEY_SENSORS)
 239                      + 1 + 2 * strlen(esc_sid)
 240                      + 1 + strlen(att) + 1);
 241
 242         sprintf(key, "%s/%s/%s", KEY_SENSORS, esc_sid, att);
 243
 244         free(esc_sid);
 245
 246         return key;
 247 }
 248
 249 struct color *
 250 config_get_sensor_color(const char *sid, const struct color *dft)
 251 {
 252         char *key, *scolor;
 253         struct color *color;
 254
 255         key = get_sensor_att_key(sid, ATT_SENSOR_COLOR);
 256
 257         scolor = gconf_client_get_string(client, key, NULL);
 258
 259         color = NULL;
 260
 261         if (scolor)
 262                 color = str_to_color(scolor);
 263
 264         if (!scolor || !color) {
 265                 color = color_new(dft->red, dft->green, dft->blue);
 266                 scolor = color_to_str(color);
 267                 gconf_client_set_string(client, key, scolor, NULL);
 268         }
 269
 270         free(scolor);
 271         free(key);
 272
 273         return color;
 274 }
 275
 276 void config_set_sensor_color(const char *sid, const struct color *color)
 277 {
 278         char *key, *scolor;
 279
 280         key = get_sensor_att_key(sid, ATT_SENSOR_COLOR);
 281         scolor = color_to_str(color);
 282
 283         gconf_client_set_string(client, key, scolor, NULL);
 284
 285         free(scolor);
 286         free(key);
 287 }
 288
 289 int config_get_sensor_alarm_high_threshold(const char *sid)
 290 {
 291         int res;
 292         char *key;
 293
 294         key = get_sensor_att_key(sid, ATT_SENSOR_ALARM_HIGH_THRESHOLD);
 295         res = gconf_client_get_int(client, key, NULL);
 296         free(key);
 297
 298         return res;
 299 }
 300
 301 void
 302 config_set_sensor_alarm_high_threshold(const char *sid, int threshold)
 303 {
 304         char *key;
 305
 306         key = get_sensor_att_key(sid, ATT_SENSOR_ALARM_HIGH_THRESHOLD);
 307         gconf_client_set_int(client, key, threshold, NULL);
 308         free(key);
 309 }
 310
 311 int config_get_sensor_alarm_low_threshold(const char *sid)
 312 {
 313         int res;
 314         char *key;
 315
 316         key = get_sensor_att_key(sid, ATT_SENSOR_ALARM_LOW_THRESHOLD);
 317         res = gconf_client_get_int(client, key, NULL);
 318         free(key);
 319
 320         return res;
 321 }
 322
 323 void
 324 config_set_sensor_alarm_low_threshold(const char *sid, int threshold)
 325 {
 326         char *key;
 327
 328         key = get_sensor_att_key(sid, ATT_SENSOR_ALARM_LOW_THRESHOLD);
 329         gconf_client_set_int(client, key, threshold, NULL);
 330         free(key);
 331 }
 332
 333 bool config_get_sensor_alarm_enabled(const char *sid)
 334 {
 335         gboolean b;
 336         char *key;
 337
 338         key = get_sensor_att_key(sid, ATT_SENSOR_ALARM_ENABLED);
 339         b = gconf_client_get_bool(client, key, NULL);
 340         free(key);
 341
 342         return b;
 343 }
 344
 345 void config_set_sensor_alarm_enabled(const char *sid, bool enabled)
 346 {
 347         char *key;
 348
 349         key = get_sensor_att_key(sid, ATT_SENSOR_ALARM_ENABLED);
 350         gconf_client_set_bool(client, key, enabled, NULL);
 351         free(key);
 352 }
 353
 354 bool config_is_sensor_enabled(const char *sid)
 355 {
 356         gboolean b;
 357         char *key;
 358
 359         key = get_sensor_att_key(sid, ATT_SENSOR_ENABLED);
 360         b = gconf_client_get_bool(client, key, NULL);
 361         free(key);
 362
 363         return b;
 364 }
 365
 366 void config_set_sensor_enabled(const char *sid, bool enabled)
 367 {
 368         char *key;
 369
 370         key = get_sensor_att_key(sid, ATT_SENSOR_ENABLED);
 371         gconf_client_set_bool(client, key, enabled, NULL);
 372         free(key);
 373 }
 374
 375 char *config_get_sensor_name(const char *sid)
 376 {
 377         char *name, *key;
 378
 379         key = get_sensor_att_key(sid, ATT_SENSOR_NAME);
 380         name = gconf_client_get_string(client, key, NULL);
 381         free(key);
 382
 383         return name;
 384 }
 385
 386 void config_set_sensor_name(const char *sid, const char *name)
 387 {
 388         char *key;
 389
 390         key = get_sensor_att_key(sid, ATT_SENSOR_NAME);
 391         gconf_client_set_string(client, key, name, NULL);
 392         free(key);
 393 }
 394
 395 int config_get_sensor_position(const char *sid)
 396 {
 397         char *key;
 398         int pos;
 399
 400         key = get_sensor_att_key(sid, ATT_SENSOR_POSITION);
 401         pos = gconf_client_get_int(client, key, NULL);
 402         free(key);
 403
 404         return pos;
 405 }
 406
 407 void config_set_sensor_position(const char *sid, int pos)
 408 {
 409         char *key;
 410
 411         key = get_sensor_att_key(sid, ATT_SENSOR_POSITION);
 412         gconf_client_set_int(client, key, pos, NULL);
 413         free(key);
 414 }
 415
 416 bool config_is_appindicator_enabled(const char *sid)
 417 {
 418         char *key;
 419         gboolean b;
 420
 421         key = get_sensor_att_key(sid, ATT_SENSOR_APPINDICATOR_DISABLED);
 422         b = gconf_client_get_bool(client, key, NULL);
 423         free(key);
 424
 425         return !b;
 426 }
 427
 428 void config_set_appindicator_enabled(const char *sid, bool enabled)
 429 {
 430         char *key;
 431
 432         key = get_sensor_att_key(sid, ATT_SENSOR_APPINDICATOR_DISABLED);
 433         gconf_client_set_bool(client, key, !enabled, NULL);
 434         free(key);
 435 }
 436
 437 bool is_slog_enabled()
 438 {
 439         return gconf_client_get_bool(client, KEY_SLOG_ENABLED, NULL);
 440 }
 441
 442 static void set_slog_enabled(bool enabled)
 443 {
 444         gconf_client_set_bool(client, KEY_SLOG_ENABLED, enabled, NULL);
 445 }
 446
 447 void config_slog_enabled_notify_add(GConfClientNotifyFunc cbk, void *data)
 448 {
 449         log_debug("config_slog_enabled_notify_add");
 450         gconf_client_add_dir(client,
 451                              KEY_SLOG_ENABLED,
 452                              GCONF_CLIENT_PRELOAD_NONE,
 453                              NULL);
 454         gconf_client_notify_add(client,
 455                                 KEY_SLOG_ENABLED,
 456                                 cbk,
 457                                 data,
 458                                 NULL,
 459                                 NULL);
 460 }
 461
 462 int config_get_slog_interval()
 463 {
 464         int res;
 465
 466         res = gconf_client_get_int(client, KEY_SLOG_INTERVAL, NULL);
 467
 468         if (res <= 0)
 469                 return 300;
 470         else
 471                 return res;
 472 }
 473
 474 static void set_slog_interval(int interval)
 475 {
 476         if (interval <= 0)
 477                 interval = 300;
 478
 479         gconf_client_set_int(client, KEY_SLOG_INTERVAL, interval, NULL);
 480 }
 481
 482 static bool is_window_decoration_enabled()
 483 {
 484         return !gconf_client_get_bool(client,
 485                                       KEY_INTERFACE_WINDOW_DECORATION_DISABLED,
 486                                       NULL);
 487 }
 488
 489 static bool is_window_keep_below_enabled()
 490 {
 491         return gconf_client_get_bool(client,
 492                                      KEY_INTERFACE_WINDOW_KEEP_BELOW_ENABLED,
 493                                      NULL);
 494 }
 495
 496 static void set_window_decoration_enabled(bool enabled)
 497 {
 498         gconf_client_set_bool
 499                 (client,
 500                  KEY_INTERFACE_WINDOW_DECORATION_DISABLED, !enabled, NULL);
 501 }
 502
 503 static void set_window_keep_below_enabled(bool enabled)
 504 {
 505         gconf_client_set_bool(client,
 506                               KEY_INTERFACE_WINDOW_KEEP_BELOW_ENABLED,
 507                               enabled, NULL);
 508 }
 509
 510 /*
 511  * Initializes the GConf client.
 512  */
 513 static void init()
 514 {
 515         if (!client)
 516                 client = gconf_client_get_default();
 517 }
 518
 519 void config_cleanup()
 520 {
 521         if (client) {
 522                 g_object_unref(client);
 523                 client = NULL;
 524         }
 525 }
 526
 527 struct config *config_load()
 528 {
 529         struct config *c;
 530
 531         init();
 532
 533         c = malloc(sizeof(struct config));
 534
 535         c->graph_bgcolor = get_background_color();
 536         c->graph_fgcolor = get_foreground_color();
 537         c->graph_bg_alpha = get_graph_background_alpha();
 538         c->alpha_channel_enabled = is_alpha_channel_enabled();
 539         c->sensorlist_position = get_sensorlist_position();
 540         c->window_decoration_enabled = is_window_decoration_enabled();
 541         c->window_keep_below_enabled = is_window_keep_below_enabled();
 542         c->slog_enabled = is_slog_enabled();
 543         c->slog_interval = config_get_slog_interval();
 544
 545         c->sensor_update_interval
 546             = gconf_client_get_int(client, KEY_SENSOR_UPDATE_INTERVAL, NULL);
 547         if (c->sensor_update_interval < 1)
 548                 c->sensor_update_interval = 1;
 549
 550         c->graph_update_interval
 551             = gconf_client_get_int(client, KEY_GRAPH_UPDATE_INTERVAL, NULL);
 552         if (c->graph_update_interval < 1)
 553                 c->graph_update_interval = 1;
 554
 555         c->graph_monitoring_duration
 556             = gconf_client_get_int(client, KEY_GRAPH_MONITORING_DURATION, NULL);
 557
 558         if (c->graph_monitoring_duration < 1)
 559                 c->graph_monitoring_duration = 10;
 560
 561         c->sensor_values_max_length
 562             =
 563             (c->graph_monitoring_duration * 60) / c->sensor_update_interval;
 564         if (c->sensor_values_max_length < 3)
 565                 c->sensor_values_max_length = 3;
 566
 567         c->menu_bar_disabled
 568                 = gconf_client_get_bool(client,
 569                                         KEY_INTERFACE_MENU_BAR_DISABLED,
 570                                         NULL);
 571
 572         c->unity_launcher_count_disabled
 573                 = gconf_client_get_bool
 574                 (client,
 575                  KEY_INTERFACE_UNITY_LAUNCHER_COUNT_DISABLED,
 576                  NULL);
 577
 578         c->hide_on_startup
 579                 = gconf_client_get_bool(client,
 580                                         KEY_INTERFACE_HIDE_ON_STARTUP,
 581                                         NULL);
 582
 583         c->window_restore_enabled
 584                 = gconf_client_get_bool(client,
 585                                         KEY_INTERFACE_WINDOW_RESTORE_ENABLED,
 586                                         NULL);
 587
 588         c->window_x = gconf_client_get_int(client,
 589                                            KEY_INTERFACE_WINDOW_X,
 590                                            NULL);
 591         c->window_y = gconf_client_get_int(client,
 592                                            KEY_INTERFACE_WINDOW_Y,
 593                                            NULL);
 594         c->window_w = gconf_client_get_int(client,
 595                                            KEY_INTERFACE_WINDOW_W,
 596                                            NULL);
 597         c->window_h = gconf_client_get_int(client,
 598                                            KEY_INTERFACE_WINDOW_H,
 599                                            NULL);
 600         c->window_divider_pos
 601                 = gconf_client_get_int(client,
 602                                        KEY_INTERFACE_WINDOW_DIVIDER_POS,
 603                                        NULL);
 604
 605         if (!c->window_restore_enabled || !c->window_w || !c->window_h) {
 606                 c->window_w = 800;
 607                 c->window_h = 200;
 608         }
 609
 610         c->temperature_unit = gconf_client_get_int
 611                 (client, KEY_INTERFACE_TEMPERATURE_UNIT, NULL);
 612
 613         return c;
 614 }
 615
 616 void config_save(const struct config *c)
 617 {
 618         set_background_color(c->graph_bgcolor);
 619         set_foreground_color(c->graph_fgcolor);
 620         set_graph_background_alpha(c->graph_bg_alpha);
 621         set_sensorlist_position(c->sensorlist_position);
 622         set_window_decoration_enabled(c->window_decoration_enabled);
 623         set_window_keep_below_enabled(c->window_keep_below_enabled);
 624         set_slog_enabled(c->slog_enabled);
 625         set_slog_interval(c->slog_interval);
 626
 627         gconf_client_set_int(client,
 628                              KEY_GRAPH_UPDATE_INTERVAL,
 629                              c->graph_update_interval, NULL);
 630
 631         gconf_client_set_int(client,
 632                              KEY_GRAPH_MONITORING_DURATION,
 633                              c->graph_monitoring_duration, NULL);
 634
 635         gconf_client_set_int(client,
 636                              KEY_SENSOR_UPDATE_INTERVAL,
 637                              c->sensor_update_interval, NULL);
 638
 639         gconf_client_set_bool(client,
 640                               KEY_INTERFACE_MENU_BAR_DISABLED,
 641                               c->menu_bar_disabled, NULL);
 642
 643         gconf_client_set_bool(client,
 644                               KEY_INTERFACE_UNITY_LAUNCHER_COUNT_DISABLED,
 645                               c->unity_launcher_count_disabled, NULL);
 646
 647         gconf_client_set_bool(client,
 648                               KEY_INTERFACE_HIDE_ON_STARTUP,
 649                               c->hide_on_startup, NULL);
 650
 651         gconf_client_set_bool(client,
 652                               KEY_INTERFACE_WINDOW_RESTORE_ENABLED,
 653                               c->window_restore_enabled,
 654                               NULL);
 655
 656         gconf_client_set_int(client, KEY_INTERFACE_WINDOW_X, c->window_x, NULL);
 657         gconf_client_set_int(client, KEY_INTERFACE_WINDOW_Y, c->window_y, NULL);
 658         gconf_client_set_int(client, KEY_INTERFACE_WINDOW_W, c->window_w, NULL);
 659         gconf_client_set_int(client, KEY_INTERFACE_WINDOW_H, c->window_h, NULL);
 660
 661         gconf_client_set_int(client,
 662                              KEY_INTERFACE_WINDOW_DIVIDER_POS,
 663                              c->window_divider_pos,
 664                              NULL);
 665
 666         gconf_client_set_int(client,
 667                              KEY_INTERFACE_TEMPERATURE_UNIT,
 668                              c->temperature_unit,
 669                              NULL);
 670 }