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