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