src/cfg.c

   1 /*
   2     Copyright (C) 2010-2011 jeanfi@gmail.com
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU 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
  20 #include <stdlib.h>
  21 #include <stdio.h>
  22 #include <string.h>
  23 #include <ctype.h>
  24
  25 #include <gconf/gconf-client.h>
  26
  27 #include "cfg.h"
  28
  29 #define KEY_SENSOR_UPDATE_INTERVAL "/apps/psensor/sensor/update_interval"
  30
  31 #define KEY_GRAPH_UPDATE_INTERVAL "/apps/psensor/graph/update_interval"
  32 #define KEY_GRAPH_MONITORING_DURATION "/apps/psensor/graph/monitoring_duration"
  33
  34 #define KEY_GRAPH_BACKGROUND_COLOR "/apps/psensor/graph/background_color"
  35 #define DEFAULT_GRAPH_BACKGROUND_COLOR "#e8f4e8f4a8f5"
  36
  37 #define KEY_GRAPH_BACKGROUND_ALPHA  "/apps/psensor/graph/background_alpha"
  38 #define DEFAULT_GRAPH_BACKGROUND_ALPHA "1.0"
  39
  40 #define KEY_GRAPH_FOREGROUND_COLOR  "/apps/psensor/graph/foreground_color"
  41 #define DEFAULT_GRAPH_FOREGROUND_COLOR "#000000000000"
  42
  43 #define KEY_ALPHA_CHANNEL_ENABLED  "/apps/psensor/graph/alpha_channel_enabled"
  44 #define DEFAULT_ALPHA_CHANNEL_ENABLED 0
  45
  46 #define KEY_INTERFACE_SENSORLIST_POSITION \
  47 "/apps/psensor/interface/sensorlist_position"
  48
  49 #define KEY_INTERFACE_WINDOW_DECORATION_DISABLED \
  50 "/apps/psensor/interface/window_decoration_disabled"
  51
  52 #define KEY_INTERFACE_WINDOW_KEEP_BELOW_ENABLED \
  53 "/apps/psensor/interface/window_keep_below_enabled"
  54
  55 #define KEY_INTERFACE_MENU_BAR_DISABLED \
  56 "/apps/psensor/interface/menu_bar_disabled"
  57
  58 #define KEY_INTERFACE_UNITY_LAUNCHER_COUNT_DISABLED \
  59 "/apps/psensor/interface/unity_launcher_count_disabled"
  60
  61 #define KEY_INTERFACE_HIDE_ON_STARTUP \
  62 "/apps/psensor/interface/hide_on_startup"
  63
  64 #define KEY_INTERFACE_WINDOW_RESTORE_ENABLED \
  65 "/apps/psensor/interface/window_restore_enabled"
  66
  67 GConfClient *client;
  68
  69 static char *get_string(char *key, char *default_value)
  70 {
  71         char *value = gconf_client_get_string(client,
  72                                               key,
  73                                               NULL);
  74
  75         if (!value) {
  76                 value = strdup(default_value);
  77
  78                 gconf_client_set_string(client, key, default_value, NULL);
  79         }
  80
  81         return value;
  82 }
  83
  84 static struct color *config_get_background_color()
  85 {
  86
  87         char *scolor = get_string(KEY_GRAPH_BACKGROUND_COLOR,
  88                                          DEFAULT_GRAPH_BACKGROUND_COLOR);
  89
  90         struct color *c = string_to_color(scolor);
  91
  92         free(scolor);
  93
  94         if (c == NULL)
  95                 return color_new(0xffff, 0xffff, 0xffff);
  96
  97         return c;
  98 }
  99
 100 static struct color *config_get_foreground_color()
 101 {
 102         char *scolor = get_string(KEY_GRAPH_FOREGROUND_COLOR,
 103                                   DEFAULT_GRAPH_FOREGROUND_COLOR);
 104
 105         struct color *c = string_to_color(scolor);
 106
 107         free(scolor);
 108
 109         if (c == NULL)
 110                 return color_new(0x0000, 0x0000, 0x0000);
 111
 112         return c;
 113 }
 114
 115 static int config_is_alpha_channel_enabled()
 116 {
 117         gboolean b = gconf_client_get_bool(client,
 118                                            KEY_ALPHA_CHANNEL_ENABLED,
 119                                            NULL);
 120
 121         return b == TRUE;
 122 }
 123
 124 static int config_get_sensorlist_position()
 125 {
 126         return gconf_client_get_int(client,
 127                                     KEY_INTERFACE_SENSORLIST_POSITION, NULL);
 128 }
 129
 130 static void config_set_sensorlist_position(int pos)
 131 {
 132         gconf_client_set_int(client,
 133                              KEY_INTERFACE_SENSORLIST_POSITION, pos, NULL);
 134 }
 135
 136 static double config_get_graph_background_alpha()
 137 {
 138         double a = gconf_client_get_float(client,
 139                                           KEY_GRAPH_BACKGROUND_ALPHA,
 140                                           NULL);
 141
 142         if (a == 0)
 143                 gconf_client_set_float(client,
 144                                        KEY_GRAPH_BACKGROUND_ALPHA, 1.0, NULL);
 145         return a;
 146 }
 147
 148 static void config_set_graph_background_alpha(double alpha)
 149 {
 150         gconf_client_set_float(client, KEY_GRAPH_BACKGROUND_ALPHA, alpha, NULL);
 151 }
 152
 153 static void config_set_background_color(struct color *color)
 154 {
 155         char *scolor = color_to_string(color);
 156
 157         if (!scolor)
 158                 scolor = strdup(DEFAULT_GRAPH_BACKGROUND_COLOR);
 159
 160         gconf_client_set_string(client,
 161                                 KEY_GRAPH_BACKGROUND_COLOR, scolor, NULL);
 162
 163         free(scolor);
 164 }
 165
 166 static void config_set_foreground_color(struct color *color)
 167 {
 168         char *scolor = color_to_string(color);
 169
 170         if (!scolor)
 171                 scolor = strdup(DEFAULT_GRAPH_FOREGROUND_COLOR);
 172
 173         gconf_client_set_string(client,
 174                                 KEY_GRAPH_FOREGROUND_COLOR, scolor, NULL);
 175
 176         free(scolor);
 177 }
 178
 179 static char *config_get_sensor_key(char *sensor_name)
 180 {
 181         char *escaped_name = gconf_escape_key(sensor_name, -1);
 182         /* /apps/psensor/sensors/[sensor_name]/color */
 183         char *key = malloc(22 + 2 * strlen(escaped_name) + 6 + 1);
 184
 185         sprintf(key, "/apps/psensor/sensors/%s/color", escaped_name);
 186
 187         free(escaped_name);
 188
 189         return key;
 190 }
 191
 192 struct color *config_get_sensor_color(char *sensor_name,
 193                                       struct color *default_color)
 194 {
 195         char *key = config_get_sensor_key(sensor_name);
 196
 197         char *scolor = gconf_client_get_string(client,
 198                                                key,
 199                                                NULL);
 200
 201         struct color *color = NULL;
 202
 203         if (scolor)
 204                 color = string_to_color(scolor);
 205
 206         if (!scolor || !color) {
 207                 color = color_new(default_color->red,
 208                                   default_color->green, default_color->blue);
 209
 210                 scolor = color_to_string(color);
 211
 212                 gconf_client_set_string(client, key, scolor, NULL);
 213         }
 214
 215         free(scolor);
 216         free(key);
 217
 218         return color;
 219 }
 220
 221 void config_set_sensor_color(char *sensor_name, struct color *color)
 222 {
 223         char *key = config_get_sensor_key(sensor_name);
 224
 225         char *scolor = color_to_string(color);
 226
 227         gconf_client_set_string(client, key, scolor, NULL);
 228
 229         free(scolor);
 230 }
 231
 232 int config_get_sensor_alarm_limit(char *sensor_name, int def)
 233 {
 234         int res;
 235         char *escaped_name = gconf_escape_key(sensor_name, -1);
 236         /* /apps/psensor/sensors/[sensor_name]/alarmlimit */
 237         char *key = malloc(22 + 2 * strlen(escaped_name) + 1 + 10 + 1);
 238
 239         sprintf(key, "/apps/psensor/sensors/%s/alarmlimit", escaped_name);
 240
 241         res = gconf_client_get_int(client, key, NULL);
 242
 243         free(escaped_name);
 244
 245         return res ? res : def;
 246 }
 247
 248 void config_set_sensor_alarm_limit(char *sensor_name, int alarm_limit)
 249 {
 250         char *escaped_name = gconf_escape_key(sensor_name, -1);
 251         /* /apps/psensor/sensors/[sensor_name]/alarmlimit */
 252         char *key = malloc(22 + 2 * strlen(escaped_name) + 1 + 10 + 1);
 253
 254         sprintf(key, "/apps/psensor/sensors/%s/alarmlimit", escaped_name);
 255
 256         gconf_client_set_int(client, key, alarm_limit, NULL);
 257
 258         free(escaped_name);
 259 }
 260
 261 int config_get_sensor_alarm_enabled(char *sid)
 262 {
 263         gboolean res;
 264         char *escaped_name = gconf_escape_key(sid, -1);
 265         /* /apps/psensor/sensors/[sensor_name]/alarmenabled */
 266         char *key = malloc(22 + 2 * strlen(escaped_name) + 1 + 12 + 1);
 267
 268         sprintf(key, "/apps/psensor/sensors/%s/alarmenabled", escaped_name);
 269
 270         res = gconf_client_get_bool(client, key, NULL);
 271
 272         free(escaped_name);
 273
 274         return res == TRUE;
 275 }
 276
 277 void config_set_sensor_alarm_enabled(char *sid, int enabled)
 278 {
 279         char *escaped_name = gconf_escape_key(sid, -1);
 280         /* /apps/psensor/sensors/[sensor_name]/alarmenabled */
 281         char *key = malloc(22 + 2 * strlen(escaped_name) + 1 + 12 + 1);
 282
 283         sprintf(key, "/apps/psensor/sensors/%s/alarmenabled", escaped_name);
 284
 285         gconf_client_set_bool(client, key, enabled, NULL);
 286
 287         free(escaped_name);
 288 }
 289
 290 int config_is_sensor_enabled(char *sid)
 291 {
 292         gboolean res;
 293         char *escaped_name = gconf_escape_key(sid, -1);
 294         /* /apps/psensor/sensors/[sensor_name]/enabled */
 295         char *key = malloc(22 + 2 * strlen(escaped_name) + 1 + 7 + 1);
 296
 297         sprintf(key, "/apps/psensor/sensors/%s/enabled", escaped_name);
 298
 299         res = gconf_client_get_bool(client, key, NULL);
 300
 301         free(escaped_name);
 302
 303         return res == TRUE;
 304
 305 }
 306
 307 void config_set_sensor_enabled(char *sid, int enabled)
 308 {
 309         char *escaped_name = gconf_escape_key(sid, -1);
 310         /* /apps/psensor/sensors/[sensor_name]/enabled */
 311         char *key = malloc(22 + 2 * strlen(escaped_name) + 1 + 7 + 1);
 312
 313         sprintf(key, "/apps/psensor/sensors/%s/enabled", escaped_name);
 314
 315         gconf_client_set_bool(client, key, enabled, NULL);
 316
 317         free(escaped_name);
 318 }
 319
 320 char *config_get_sensor_name(char *sid)
 321 {
 322         char *res;
 323         char *escaped_name = gconf_escape_key(sid, -1);
 324         /* /apps/psensor/sensors/[sensor_name]/name */
 325         char *key = malloc(22 + 2 * strlen(escaped_name) + 1 + 4 + 1);
 326
 327         sprintf(key, "/apps/psensor/sensors/%s/name", escaped_name);
 328
 329         res = gconf_client_get_string(client, key, NULL);
 330
 331         free(escaped_name);
 332
 333         return res;
 334 }
 335
 336 void config_set_sensor_name(char *sid, const char *name)
 337 {
 338         char *escaped_name = gconf_escape_key(sid, -1);
 339         /* /apps/psensor/sensors/[sensor_name]/name */
 340         char *key = malloc(22 + 2 * strlen(escaped_name) + 1 + 4 + 1);
 341
 342         sprintf(key, "/apps/psensor/sensors/%s/name", escaped_name);
 343
 344         gconf_client_set_string(client, key, name, NULL);
 345
 346         free(escaped_name);
 347 }
 348
 349 static int config_is_window_decoration_enabled()
 350 {
 351         gboolean b;
 352
 353         b = gconf_client_get_bool(client,
 354                                   KEY_INTERFACE_WINDOW_DECORATION_DISABLED,
 355                                   NULL);
 356
 357         return b == FALSE;
 358 }
 359
 360 static int config_is_window_keep_below_enabled()
 361 {
 362         gboolean b;
 363
 364         b = gconf_client_get_bool(client,
 365                                   KEY_INTERFACE_WINDOW_KEEP_BELOW_ENABLED,
 366                                   NULL);
 367
 368         return b == TRUE;
 369 }
 370
 371 static void config_set_window_decoration_enabled(int enabled)
 372 {
 373         if (enabled)
 374                 gconf_client_set_bool
 375                     (client,
 376                      KEY_INTERFACE_WINDOW_DECORATION_DISABLED, FALSE, NULL);
 377         else
 378                 gconf_client_set_bool
 379                     (client,
 380                      KEY_INTERFACE_WINDOW_DECORATION_DISABLED, TRUE, NULL);
 381 }
 382
 383 static void config_set_window_keep_below_enabled(int enabled)
 384 {
 385         if (enabled)
 386                 gconf_client_set_bool(client,
 387                                       KEY_INTERFACE_WINDOW_KEEP_BELOW_ENABLED,
 388                                       TRUE, NULL);
 389         else
 390                 gconf_client_set_bool(client,
 391                                       KEY_INTERFACE_WINDOW_KEEP_BELOW_ENABLED,
 392                                       FALSE, NULL);
 393 }
 394
 395 void config_init()
 396 {
 397         client = gconf_client_get_default();
 398 }
 399
 400 void config_cleanup()
 401 {
 402         if (client) {
 403                 g_object_unref(client);
 404                 client = NULL;
 405         }
 406 }
 407
 408 struct config *config_load()
 409 {
 410         struct config *c;
 411
 412         c = malloc(sizeof(struct config));
 413
 414         c->graph_bgcolor = config_get_background_color();
 415         c->graph_fgcolor = config_get_foreground_color();
 416         c->graph_bg_alpha = config_get_graph_background_alpha();
 417         c->alpha_channel_enabled = config_is_alpha_channel_enabled();
 418         c->sensorlist_position = config_get_sensorlist_position();
 419         c->window_decoration_enabled = config_is_window_decoration_enabled();
 420         c->window_keep_below_enabled = config_is_window_keep_below_enabled();
 421
 422         c->sensor_update_interval
 423             = gconf_client_get_int(client, KEY_SENSOR_UPDATE_INTERVAL, NULL);
 424         if (c->sensor_update_interval < 1)
 425                 c->sensor_update_interval = 1;
 426
 427         c->graph_update_interval
 428             = gconf_client_get_int(client, KEY_GRAPH_UPDATE_INTERVAL, NULL);
 429         if (c->graph_update_interval < 1)
 430                 c->graph_update_interval = 1;
 431
 432         c->graph_monitoring_duration
 433             = gconf_client_get_int(client, KEY_GRAPH_MONITORING_DURATION, NULL);
 434
 435         if (c->graph_monitoring_duration < 1)
 436                 c->graph_monitoring_duration = 10;
 437
 438         c->sensor_values_max_length
 439             =
 440             (c->graph_monitoring_duration * 60) / c->sensor_update_interval;
 441         if (c->sensor_values_max_length < 3)
 442                 c->sensor_values_max_length = 3;
 443
 444         c->menu_bar_disabled
 445                 = gconf_client_get_bool(client,
 446                                         KEY_INTERFACE_MENU_BAR_DISABLED,
 447                                         NULL);
 448
 449         c->unity_launcher_count_disabled
 450                 = gconf_client_get_bool
 451                 (client,
 452                  KEY_INTERFACE_UNITY_LAUNCHER_COUNT_DISABLED,
 453                  NULL);
 454
 455         c->hide_on_startup
 456                 = gconf_client_get_bool(client,
 457                                         KEY_INTERFACE_HIDE_ON_STARTUP,
 458                                         NULL);
 459
 460         c->window_restore_enabled
 461                 = gconf_client_get_bool(client,
 462                                         KEY_INTERFACE_WINDOW_RESTORE_ENABLED,
 463                                         NULL);
 464
 465         return c;
 466 }
 467
 468 void config_save(struct config *c)
 469 {
 470         config_set_background_color(c->graph_bgcolor);
 471         config_set_foreground_color(c->graph_fgcolor);
 472         config_set_graph_background_alpha(c->graph_bg_alpha);
 473         config_set_sensorlist_position(c->sensorlist_position);
 474         config_set_window_decoration_enabled(c->window_decoration_enabled);
 475         config_set_window_keep_below_enabled(c->window_keep_below_enabled);
 476
 477         gconf_client_set_int(client,
 478                              KEY_GRAPH_UPDATE_INTERVAL,
 479                              c->graph_update_interval, NULL);
 480
 481         gconf_client_set_int(client,
 482                              KEY_GRAPH_MONITORING_DURATION,
 483                              c->graph_monitoring_duration, NULL);
 484
 485         gconf_client_set_int(client,
 486                              KEY_SENSOR_UPDATE_INTERVAL,
 487                              c->sensor_update_interval, NULL);
 488
 489         gconf_client_set_bool(client,
 490                               KEY_INTERFACE_MENU_BAR_DISABLED,
 491                               c->menu_bar_disabled, NULL);
 492
 493         gconf_client_set_bool(client,
 494                               KEY_INTERFACE_UNITY_LAUNCHER_COUNT_DISABLED,
 495                               c->unity_launcher_count_disabled, NULL);
 496
 497         gconf_client_set_bool(client,
 498                               KEY_INTERFACE_HIDE_ON_STARTUP,
 499                               c->hide_on_startup, NULL);
 500
 501         gconf_client_set_bool(client,
 502                               KEY_INTERFACE_WINDOW_RESTORE_ENABLED,
 503                               c->window_restore_enabled,
 504                               NULL);
 505 }