src/cfg.c

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