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