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