src/cfg.c

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