src/cfg.c

   1 /*
   2     Copyright (C) 2010-2011 wpitchoune@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 GConfClient *client;
  56
  57 char *config_get_string(char *key, char *default_value)
  58 {
  59         char *value = gconf_client_get_string(client,
  60                                               key,
  61                                               NULL);
  62
  63         if (!value) {
  64                 value = strdup(default_value);
  65
  66                 gconf_client_set_string(client, key, default_value, NULL);
  67         }
  68
  69         return value;
  70 }
  71
  72 struct color *config_get_background_color()
  73 {
  74
  75         char *scolor = config_get_string(KEY_GRAPH_BACKGROUND_COLOR,
  76                                          DEFAULT_GRAPH_BACKGROUND_COLOR);
  77
  78         struct color *c = string_to_color(scolor);
  79
  80         free(scolor);
  81
  82         if (c == NULL)
  83                 return color_new(0xffff, 0xffff, 0xffff);
  84
  85         return c;
  86 }
  87
  88 struct color *config_get_foreground_color()
  89 {
  90         char *scolor = config_get_string(KEY_GRAPH_FOREGROUND_COLOR,
  91                                          DEFAULT_GRAPH_FOREGROUND_COLOR);
  92
  93         struct color *c = string_to_color(scolor);
  94
  95         free(scolor);
  96
  97         if (c == NULL)
  98                 return color_new(0x0000, 0x0000, 0x0000);
  99
 100         return c;
 101 }
 102
 103 int config_is_alpha_channel_enabled()
 104 {
 105         gboolean b = gconf_client_get_bool(client,
 106                                            KEY_ALPHA_CHANNEL_ENABLED,
 107                                            NULL);
 108
 109         return b == TRUE;
 110 }
 111
 112 void config_set_alpha_channel_enabled(int enabled)
 113 {
 114         if (enabled)
 115                 gconf_client_set_bool(client,
 116                                       KEY_ALPHA_CHANNEL_ENABLED, TRUE, NULL);
 117         else
 118                 gconf_client_set_bool(client,
 119                                       KEY_ALPHA_CHANNEL_ENABLED, FALSE, NULL);
 120 }
 121
 122 int config_get_sensorlist_position()
 123 {
 124         return gconf_client_get_int(client,
 125                                     KEY_INTERFACE_SENSORLIST_POSITION, NULL);
 126 }
 127
 128 void config_set_sensorlist_position(int pos)
 129 {
 130         gconf_client_set_int(client,
 131                              KEY_INTERFACE_SENSORLIST_POSITION, pos, NULL);
 132 }
 133
 134 double config_get_graph_background_alpha()
 135 {
 136         double a = gconf_client_get_float(client,
 137                                           KEY_GRAPH_BACKGROUND_ALPHA,
 138                                           NULL);
 139
 140         if (a == 0)
 141                 gconf_client_set_float(client,
 142                                        KEY_GRAPH_BACKGROUND_ALPHA, 1.0, NULL);
 143         return a;
 144 }
 145
 146 void config_set_graph_background_alpha(double alpha)
 147 {
 148         gconf_client_set_float(client, KEY_GRAPH_BACKGROUND_ALPHA, alpha, NULL);
 149 }
 150
 151 void config_set_background_color(struct color *color)
 152 {
 153         char *scolor = color_to_string(color);
 154
 155         if (!scolor)
 156                 scolor = strdup(DEFAULT_GRAPH_BACKGROUND_COLOR);
 157
 158         gconf_client_set_string(client,
 159                                 KEY_GRAPH_BACKGROUND_COLOR, scolor, NULL);
 160
 161         free(scolor);
 162 }
 163
 164 void config_set_foreground_color(struct color *color)
 165 {
 166         char *scolor = color_to_string(color);
 167
 168         if (!scolor)
 169                 scolor = strdup(DEFAULT_GRAPH_FOREGROUND_COLOR);
 170
 171         gconf_client_set_string(client,
 172                                 KEY_GRAPH_FOREGROUND_COLOR, scolor, NULL);
 173
 174         free(scolor);
 175 }
 176
 177 char *config_get_sensor_key(char *sensor_name)
 178 {
 179         char *escaped_name = gconf_escape_key(sensor_name, -1);
 180         /* /apps/psensor/sensors/[sensor_name]/color */
 181         char *key = malloc(22 + 2 * strlen(escaped_name) + 6 + 1);
 182
 183         sprintf(key, "/apps/psensor/sensors/%s/color", escaped_name);
 184
 185         free(escaped_name);
 186
 187         return key;
 188 }
 189
 190 struct color *config_get_sensor_color(char *sensor_name,
 191                                       struct color *default_color)
 192 {
 193         char *key = config_get_sensor_key(sensor_name);
 194
 195         char *scolor = gconf_client_get_string(client,
 196                                                key,
 197                                                NULL);
 198
 199         struct color *color = NULL;
 200
 201         if (scolor)
 202                 color = string_to_color(scolor);
 203
 204         if (!scolor || !color) {
 205                 color = color_new(default_color->red,
 206                                   default_color->green, default_color->blue);
 207
 208                 scolor = color_to_string(color);
 209
 210                 gconf_client_set_string(client, key, scolor, NULL);
 211         }
 212
 213         free(scolor);
 214         free(key);
 215
 216         return color;
 217 }
 218
 219 void config_set_sensor_color(char *sensor_name, struct color *color)
 220 {
 221         char *key = config_get_sensor_key(sensor_name);
 222
 223         char *scolor = color_to_string(color);
 224
 225         gconf_client_set_string(client, key, scolor, NULL);
 226
 227         free(scolor);
 228 }
 229
 230 int config_get_sensor_alarm_limit(char *sensor_name, int def)
 231 {
 232         int res;
 233         char *escaped_name = gconf_escape_key(sensor_name, -1);
 234         /* /apps/psensor/sensors/[sensor_name]/alarmlimit */
 235         char *key = malloc(22 + 2 * strlen(escaped_name) + 1 + 10 + 1);
 236
 237         sprintf(key, "/apps/psensor/sensors/%s/alarmlimit", escaped_name);
 238
 239         res = gconf_client_get_int(client, key, NULL);
 240
 241         free(escaped_name);
 242
 243         return res ? res : def;
 244 }
 245
 246 void config_set_sensor_alarm_limit(char *sensor_name, int alarm_limit)
 247 {
 248         char *escaped_name = gconf_escape_key(sensor_name, -1);
 249         /* /apps/psensor/sensors/[sensor_name]/alarmlimit */
 250         char *key = malloc(22 + 2 * strlen(escaped_name) + 1 + 10 + 1);
 251
 252         sprintf(key, "/apps/psensor/sensors/%s/alarmlimit", escaped_name);
 253
 254         gconf_client_set_int(client, key, alarm_limit, NULL);
 255
 256         free(escaped_name);
 257 }
 258
 259 int config_get_sensor_alarm_enabled(char *sid)
 260 {
 261         gboolean res;
 262         char *escaped_name = gconf_escape_key(sid, -1);
 263         /* /apps/psensor/sensors/[sensor_name]/alarmenabled */
 264         char *key = malloc(22 + 2 * strlen(escaped_name) + 1 + 12 + 1);
 265
 266         sprintf(key, "/apps/psensor/sensors/%s/alarmenabled", escaped_name);
 267
 268         res = gconf_client_get_bool(client, key, NULL);
 269
 270         free(escaped_name);
 271
 272         return res == TRUE;
 273 }
 274
 275 void config_set_sensor_alarm_enabled(char *sid, int enabled)
 276 {
 277         char *escaped_name = gconf_escape_key(sid, -1);
 278         /* /apps/psensor/sensors/[sensor_name]/alarmenabled */
 279         char *key = malloc(22 + 2 * strlen(escaped_name) + 1 + 12 + 1);
 280
 281         sprintf(key, "/apps/psensor/sensors/%s/alarmenabled", escaped_name);
 282
 283         gconf_client_set_bool(client, key, enabled, NULL);
 284
 285         free(escaped_name);
 286 }
 287
 288 int config_is_sensor_enabled(char *sid)
 289 {
 290         gboolean res;
 291         char *escaped_name = gconf_escape_key(sid, -1);
 292         /* /apps/psensor/sensors/[sensor_name]/enabled */
 293         char *key = malloc(22 + 2 * strlen(escaped_name) + 1 + 7 + 1);
 294
 295         sprintf(key, "/apps/psensor/sensors/%s/enabled", escaped_name);
 296
 297         res = gconf_client_get_bool(client, key, NULL);
 298
 299         free(escaped_name);
 300
 301         return res == TRUE;
 302
 303 }
 304
 305 void config_set_sensor_enabled(char *sid, int enabled)
 306 {
 307         char *escaped_name = gconf_escape_key(sid, -1);
 308         /* /apps/psensor/sensors/[sensor_name]/enabled */
 309         char *key = malloc(22 + 2 * strlen(escaped_name) + 1 + 7 + 1);
 310
 311         sprintf(key, "/apps/psensor/sensors/%s/enabled", escaped_name);
 312
 313         gconf_client_set_bool(client, key, enabled, NULL);
 314
 315         free(escaped_name);
 316 }
 317
 318 char *config_get_sensor_name(char *sid)
 319 {
 320         char *res;
 321         char *escaped_name = gconf_escape_key(sid, -1);
 322         /* /apps/psensor/sensors/[sensor_name]/name */
 323         char *key = malloc(22 + 2 * strlen(escaped_name) + 1 + 4 + 1);
 324
 325         sprintf(key, "/apps/psensor/sensors/%s/name", escaped_name);
 326
 327         res = gconf_client_get_string(client, key, NULL);
 328
 329         free(escaped_name);
 330
 331         return res;
 332 }
 333
 334 void config_set_sensor_name(char *sid, const char *name)
 335 {
 336         char *escaped_name = gconf_escape_key(sid, -1);
 337         /* /apps/psensor/sensors/[sensor_name]/name */
 338         char *key = malloc(22 + 2 * strlen(escaped_name) + 1 + 4 + 1);
 339
 340         sprintf(key, "/apps/psensor/sensors/%s/name", escaped_name);
 341
 342         gconf_client_set_string(client, key, name, NULL);
 343
 344         free(escaped_name);
 345 }
 346
 347 int config_is_window_decoration_enabled()
 348 {
 349         gboolean b;
 350
 351         b = gconf_client_get_bool(client,
 352                                   KEY_INTERFACE_WINDOW_DECORATION_DISABLED,
 353                                   NULL);
 354
 355         return b == FALSE;
 356 }
 357
 358 int config_is_window_keep_below_enabled()
 359 {
 360         gboolean b;
 361
 362         b = gconf_client_get_bool(client,
 363                                   KEY_INTERFACE_WINDOW_KEEP_BELOW_ENABLED,
 364                                   NULL);
 365
 366         return b == TRUE;
 367 }
 368
 369 void config_set_window_decoration_enabled(int enabled)
 370 {
 371         if (enabled)
 372                 gconf_client_set_bool
 373                     (client,
 374                      KEY_INTERFACE_WINDOW_DECORATION_DISABLED, FALSE, NULL);
 375         else
 376                 gconf_client_set_bool
 377                     (client,
 378                      KEY_INTERFACE_WINDOW_DECORATION_DISABLED, TRUE, NULL);
 379 }
 380
 381 void config_set_window_keep_below_enabled(int enabled)
 382 {
 383         if (enabled)
 384                 gconf_client_set_bool(client,
 385                                       KEY_INTERFACE_WINDOW_KEEP_BELOW_ENABLED,
 386                                       TRUE, NULL);
 387         else
 388                 gconf_client_set_bool(client,
 389                                       KEY_INTERFACE_WINDOW_KEEP_BELOW_ENABLED,
 390                                       FALSE, NULL);
 391 }
 392
 393 void config_init()
 394 {
 395         client = gconf_client_get_default();
 396 }
 397
 398 struct config *config_load()
 399 {
 400         struct config *cfg = malloc(sizeof(struct config));
 401
 402         cfg->graph_bgcolor = config_get_background_color();
 403         cfg->graph_fgcolor = config_get_foreground_color();
 404         cfg->graph_bg_alpha = config_get_graph_background_alpha();
 405         cfg->alpha_channel_enabled = config_is_alpha_channel_enabled();
 406         cfg->sensorlist_position = config_get_sensorlist_position();
 407         cfg->window_decoration_enabled = config_is_window_decoration_enabled();
 408         cfg->window_keep_below_enabled = config_is_window_keep_below_enabled();
 409
 410         cfg->sensor_update_interval
 411             = gconf_client_get_int(client, KEY_SENSOR_UPDATE_INTERVAL, NULL);
 412         if (cfg->sensor_update_interval < 1)
 413                 cfg->sensor_update_interval = 1;
 414
 415         cfg->graph_update_interval
 416             = gconf_client_get_int(client, KEY_GRAPH_UPDATE_INTERVAL, NULL);
 417         if (cfg->graph_update_interval < 1)
 418                 cfg->graph_update_interval = 1;
 419
 420         cfg->graph_monitoring_duration
 421             = gconf_client_get_int(client, KEY_GRAPH_MONITORING_DURATION, NULL);
 422
 423         if (cfg->graph_monitoring_duration < 1)
 424                 cfg->graph_monitoring_duration = 10;
 425
 426         cfg->sensor_values_max_length
 427             =
 428             (cfg->graph_monitoring_duration * 60) / cfg->sensor_update_interval;
 429         if (cfg->sensor_values_max_length < 3)
 430                 cfg->sensor_values_max_length = 3;
 431
 432         return cfg;
 433 }
 434
 435 void config_save(struct config *cfg)
 436 {
 437         config_set_background_color(cfg->graph_bgcolor);
 438         config_set_foreground_color(cfg->graph_fgcolor);
 439         config_set_graph_background_alpha(cfg->graph_bg_alpha);
 440         config_set_sensorlist_position(cfg->sensorlist_position);
 441         config_set_window_decoration_enabled(cfg->window_decoration_enabled);
 442         config_set_window_keep_below_enabled(cfg->window_keep_below_enabled);
 443
 444         gconf_client_set_int(client,
 445                              KEY_GRAPH_UPDATE_INTERVAL,
 446                              cfg->graph_update_interval, NULL);
 447
 448         gconf_client_set_int(client,
 449                              KEY_GRAPH_MONITORING_DURATION,
 450                              cfg->graph_monitoring_duration, NULL);
 451
 452         gconf_client_set_int(client,
 453                              KEY_SENSOR_UPDATE_INTERVAL,
 454                              cfg->sensor_update_interval, NULL);
 455
 456 }