src/cfg.c

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