summaryrefslogtreecommitdiff
path: root/sensors-applet/sensors-applet-settings.c
blob: 70dda3d4069b87d9c6b0b2e37f024e036175d368 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
/*
 * Copyright (C) 2005-2009 Alex Murray <murray.alex@gmail.com>
 *               2013 Stefano Karapetsas <stefano@karapetsas.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif /* HAVE_CONFIG_H */

#include <string.h>
#include <glib.h>
#include "sensors-applet.h"
#include "sensors-applet-settings.h"

/* #define SORT_DEBUG */
#ifdef SORT_DEBUG
#include <syslog.h>
#endif

/* these must be as the gsettings schema in file org.mate.sensors-applet.gschema.xml.in
 * gsettings gvariant type string */
#define GSGVTS "s"
/* gsettings gvariant type string for the array */
#define GSGVTSA "as"


gchar* sensors_applet_settings_get_unique_id (const gchar *interface, const gchar *id, const gchar *path) {
    gchar *unique_id = NULL;
    gchar *unique_id_hash = NULL;
    GChecksum *checksum = NULL;
    guint8 digest[16];
    gsize digest_len = sizeof (digest);

    unique_id = g_strdup_printf ("%s/%s/%s", interface, id, path);

    checksum = g_checksum_new (G_CHECKSUM_MD5);
    g_checksum_update (checksum, (const guchar *) unique_id, strlen (unique_id));
    g_checksum_get_digest (checksum, digest, &digest_len);
    g_assert (digest_len == 16);

    unique_id_hash = g_strdup (g_checksum_get_string (checksum));

    g_checksum_free (checksum);
    g_free (unique_id);

    return unique_id_hash;
}

/* load sensors from gsettings with sorting */
gboolean sensors_applet_settings_load_sensors (SensorsApplet *sensors_applet) {
    /* everything gets stored except alarm timeout indexes, which
    we set to -1, and visible which we set to false for all
    parent nodes and true for all child nodes */

    gchar *applet_path = NULL;
    /* not sure about pointer, it is unclear if it is freed by loop, probably yes */
    GVariantIter *iter = NULL;
    gchar *gsuid = NULL;

    /* string variables, to help free up memory in loop */
    gchar *current_path = NULL;
    gchar *current_id = NULL;
    gchar *current_label = NULL;
    gchar *current_interface = NULL;
    gchar *current_low_alarm_command = NULL;
    gchar *current_high_alarm_command = NULL;
    gchar *current_graph_color = NULL;

    /* get gsettings path for applet */
    applet_path = mate_panel_applet_get_preferences_path (sensors_applet->applet);

    /* get sensors-list array from gsettings */
    g_settings_get (sensors_applet->settings, "sensors-list", GSGVTSA, &iter);

    /* load sensor data into applet one by one
     * first get unique id for the sensor
     * then load sensor data from gsettings
     * then add sensor
     * gsuid is freed by g_variant_iter_loop() */
    while (g_variant_iter_loop (iter, GSGVTS, &gsuid)) {

        /* load sensor data from gsettings individually
         * g_strdup_printf doesn't free args!
         * applet_path is freed at the end */
        gchar *path = g_strdup_printf ("%s%s/", applet_path, gsuid);
        /*g_free (gsuid);   // freed by loop */

        /* make a schema which points to one sensor data */
        GSettings *settings;
        settings = g_settings_new_with_path ("org.mate.sensors-applet.sensor", path);
        g_free (path);

        /* laod sensor data to temp variables
         * g_settings_get_string allocates memory!
         * sensors_applet_add_sensor() gtk_tree_store_set() copies strings, so free them */
        sensors_applet_add_sensor(sensors_applet,
            current_path = g_settings_get_string (settings, PATH),
            current_id = g_settings_get_string (settings, ID),
            current_label = g_settings_get_string (settings, LABEL),
            current_interface = g_settings_get_string (settings, INTERFACE),
            g_settings_get_int (settings, SENSOR_TYPE),
            g_settings_get_boolean (settings, ENABLED),
            g_settings_get_double (settings, LOW_VALUE),
            g_settings_get_double (settings, HIGH_VALUE),
            g_settings_get_boolean (settings, ALARM_ENABLED),
            current_low_alarm_command = g_settings_get_string (settings, LOW_ALARM_COMMAND),
            current_high_alarm_command = g_settings_get_string (settings, HIGH_ALARM_COMMAND),
            g_settings_get_int (settings, ALARM_TIMEOUT),
            g_settings_get_double (settings, MULTIPLIER),
            g_settings_get_double (settings, OFFSET),
            g_settings_get_int (settings, ICON_TYPE),
            current_graph_color = g_settings_get_string (settings, GRAPH_COLOR));

        g_free (current_path);
        g_free (current_id);
        g_free (current_label);
        g_free (current_interface);
        g_free (current_low_alarm_command);
        g_free (current_high_alarm_command);
        g_free (current_graph_color);

        g_object_unref (settings);

    }

    g_free (applet_path);

    return TRUE;
}

#ifdef SORT_DEBUG
/* print a gtk_tree_store (for debug) */
static void sensors_applet_settings_print_sensors_tree (SensorsApplet *sensors_applet) {

    g_assert(sensors_applet);
    g_assert(sensors_applet->sensors);

    GtkTreeIter interfaces_iter;
    GtkTreeIter sensors_iter;
    gboolean not_end_of_interfaces = TRUE;
    gboolean not_end_of_sensors = TRUE;
    gint interfaces_counter = 0;
    gint sensors_counter = 0;

    gchar *interface_name = NULL;
    gchar *sensor_id = NULL;
    gchar *sensor_path = NULL;
    gchar *sensor_hash = NULL;

    /* iterate through the sensor tree
     * code from sensors-applet.c sensors_applet_add_sensor()
     * first go through the interfaces */
    for (not_end_of_interfaces = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(sensors_applet->sensors), &interfaces_iter);
        not_end_of_interfaces;
        not_end_of_interfaces = gtk_tree_model_iter_next(GTK_TREE_MODEL(sensors_applet->sensors), &interfaces_iter), interfaces_counter++) {

        /* get interface name */
        gtk_tree_model_get(GTK_TREE_MODEL(sensors_applet->sensors), &interfaces_iter, INTERFACE_COLUMN, &interface_name, -1);

        /* print interface name */
        syslog(LOG_ERR, "#%d interface name: %s\n", interfaces_counter, interface_name);

        /* then go through the individual sensors under one interface */
        for (not_end_of_sensors = gtk_tree_model_iter_children(GTK_TREE_MODEL(sensors_applet->sensors), &sensors_iter,  &interfaces_iter);
            not_end_of_sensors;
            not_end_of_sensors = gtk_tree_model_iter_next(GTK_TREE_MODEL(sensors_applet->sensors), &sensors_iter), sensors_counter++) {

            gtk_tree_model_get(GTK_TREE_MODEL(sensors_applet->sensors), &sensors_iter,
                       PATH_COLUMN, &sensor_path,
                       ID_COLUMN, &sensor_id,
                       -1);

            sensor_hash = sensors_applet_settings_get_unique_id (interface_name, sensor_id, sensor_path);

            /* print sensor data */
            syslog(LOG_ERR, "\t#%d sensor id: %s\n", sensors_counter, sensor_id);
            syslog(LOG_ERR, "\t#%d sensor path: %s\n", sensors_counter, sensor_path);
            syslog(LOG_ERR, "\t#%d sensor hash: %s\n\n", sensors_counter, sensor_hash);

            g_free(sensor_id);
            g_free(sensor_path);
            g_free(sensor_hash);

        }

        g_free(interface_name);

    }

}
#endif

/* compare two iters using their paths
 * kinda same as active_sensor_compare () */
static gint sensors_applet_settings_sort_sensors_iter_compare (SensorsApplet *sensors_applet, GtkTreeIter ti_a, GtkTreeIter ti_b) {

    GtkTreePath *tp_a;
    GtkTreePath *tp_b;
    gint ret_val;

    tp_a = gtk_tree_model_get_path (GTK_TREE_MODEL(sensors_applet->sensors), &ti_a);
    tp_b = gtk_tree_model_get_path (GTK_TREE_MODEL(sensors_applet->sensors), &ti_b);

    ret_val = gtk_tree_path_compare(tp_a, tp_b);

    gtk_tree_path_free(tp_a);
    gtk_tree_path_free(tp_b);

    return ret_val;
}

/* find two sensors in the sensors tree based on their hash and sort them
 * Return codes:
 * 0: something went very wrong...
 * 1: normal run, a and b are in place
 * 2: hash_b has already been removed from the system
 * 3: hash_a is not found */
static gint sensors_applet_settings_sort_sensors_sort (SensorsApplet *sensors_applet,
                                                           const gchar *hash_a,
                                                           const gchar *hash_b,
                                                           gboolean a_is_first) {

    g_assert(sensors_applet);
    g_assert(sensors_applet->sensors);

    GtkTreeIter interfaces_iter;
    GtkTreeIter sensors_iter;
    gboolean not_end_of_interfaces = TRUE;
    gboolean not_end_of_sensors = TRUE;

    gchar *interface_name = NULL;
    gchar *sensor_id = NULL;
    gchar *sensor_path = NULL;
    gchar *sensor_hash = NULL;

    GtkTreeIter interface_iter_a;
    GtkTreeIter interface_iter_b;
    GtkTreeIter sensor_iter_a;
    GtkTreeIter sensor_iter_b;
    gboolean found_a = FALSE;
    gboolean found_b = FALSE;

    /* iterate through the sensor tree
     * code from sensors-applet.c sensors_applet_add_sensor()
     * first go through the interfaces */
    for (not_end_of_interfaces = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(sensors_applet->sensors), &interfaces_iter);
        not_end_of_interfaces;
        not_end_of_interfaces = gtk_tree_model_iter_next(GTK_TREE_MODEL(sensors_applet->sensors), &interfaces_iter)) {

        /* get interface name */
        gtk_tree_model_get(GTK_TREE_MODEL(sensors_applet->sensors), &interfaces_iter, INTERFACE_COLUMN, &interface_name, -1);

        /* then go through the individual sensors under one interface */
        for (not_end_of_sensors = gtk_tree_model_iter_children(GTK_TREE_MODEL(sensors_applet->sensors), &sensors_iter,  &interfaces_iter);
            not_end_of_sensors;
            not_end_of_sensors = gtk_tree_model_iter_next(GTK_TREE_MODEL(sensors_applet->sensors), &sensors_iter)) {

            gtk_tree_model_get(GTK_TREE_MODEL(sensors_applet->sensors), &sensors_iter,
                       PATH_COLUMN, &sensor_path,
                       ID_COLUMN, &sensor_id,
                       -1);

            sensor_hash = sensors_applet_settings_get_unique_id (interface_name, sensor_id, sensor_path);

            /* save interface_name and iters for swap */
            if (g_ascii_strcasecmp(sensor_hash, hash_a) == 0) {
                /* can copy by value, don't free */
                interface_iter_a = interfaces_iter;
                sensor_iter_a = sensors_iter;
                found_a = TRUE;
            }

            if (g_ascii_strcasecmp(sensor_hash, hash_b) == 0) {
                interface_iter_b = interfaces_iter;
                sensor_iter_b = sensors_iter;
                found_b = TRUE;
            }

            g_free(sensor_id);
            g_free(sensor_path);
            g_free(sensor_hash);

            /* break after freeing loop variables */
            if (found_a && found_b) {
                break;
            }
        }

        g_free(interface_name);

        /* break after freeing loop variables */
        if (found_a && found_b) {
            break;
        }
    }

    /* make the switch */
    if (found_a && found_b) {

        GtkTreeIter first_iter;
        GtkTreeIter iter_next;

        gint ret_val;

        /* set a's interface to be the first interface in the sensors tree */
        if (a_is_first) {

            /* this 'fails' if the tree is empty, but this is already checked with the first loop */
            gtk_tree_model_get_iter_first (GTK_TREE_MODEL(sensors_applet->sensors), &first_iter);

            /* we are only interested in the case, where the two are not equal
             * that means the a's interface is not the first interface */
            if ( 0 != sensors_applet_settings_sort_sensors_iter_compare (sensors_applet, first_iter, interface_iter_a)) {

                /* it should be, so it needs to be moved to the first position */
                gtk_tree_store_move_after (GTK_TREE_STORE(sensors_applet->sensors), &interface_iter_a, NULL);
            }

        }

        /* check b's interface position
         * (1) if it is before a's if. - not possible, bc I have just set a's if. as first
         * afterwards every new if. will be set right after (one) a's if.
         * (0) if it is the same as a's, noop
         * (-1) if it is after a, check if it is right after a, if not move it there */
        ret_val = sensors_applet_settings_sort_sensors_iter_compare (sensors_applet, interface_iter_a, interface_iter_b);
        if (-1 == ret_val) {

            /* set iter_next to the iter after a's if. iter, can copy like this */
            iter_next = interface_iter_a;
            /* this 'fails' if there is no node after a's if. iter, but we already know, that at least b's if. iter is */
            gtk_tree_model_iter_next (GTK_TREE_MODEL(sensors_applet->sensors), &iter_next);

            /* the node right after a's if. iter is not b's if. iter, so move b's if. iter */
            if (0 != sensors_applet_settings_sort_sensors_iter_compare (sensors_applet, iter_next, interface_iter_b)) {

                gtk_tree_store_move_after (GTK_TREE_STORE(sensors_applet->sensors), &interface_iter_b, &interface_iter_a);
            }
        }


        /* at this point the interfaces are sorted, the sensors are next */
        /* set a to be the first sensor in the sensors tree, under the first if. iter */
        if (a_is_first) {

            /* this 'fails' if the tree is empty, but at least a is in it */
            gtk_tree_model_iter_children(GTK_TREE_MODEL(sensors_applet->sensors), &first_iter,  &interface_iter_a);

            /* we are only interested in the case, where the two are not equal
             * that means the a is not the first sensor */
            if ( 0 != sensors_applet_settings_sort_sensors_iter_compare (sensors_applet, first_iter, sensor_iter_a)) {

                /* it should be, so it needs to be moved to the first position */
                gtk_tree_store_move_after (GTK_TREE_STORE(sensors_applet->sensors), &sensor_iter_a, NULL);
            }

        }

        /* check b's position
         * if a's if. and b's if is the same
         * (1) if it is before a's if. - not possible, bc I have just set a as first
         * afterwards every new sensor will be set right after (one) a
         * (0) if it is the same as a's, not possible, a and b would be equal
         * (-1) if it is after a, check if it is right after a, if not move it there */
        if (0 == ret_val && -1 == sensors_applet_settings_sort_sensors_iter_compare (sensors_applet, sensor_iter_a, sensor_iter_b)) {

            /* set iter_next to the iter after a's iter, can copy like this */
            iter_next = sensor_iter_a;
            /* this 'fails' if there is no node after a's iter, but we already know, that at least b's iter is */
            gtk_tree_model_iter_next (GTK_TREE_MODEL(sensors_applet->sensors), &iter_next);

            /* the node right after a's iter is not b's iter, so move b's iter */
            if (0 != sensors_applet_settings_sort_sensors_iter_compare (sensors_applet, iter_next, sensor_iter_b)) {

                gtk_tree_store_move_after (GTK_TREE_STORE(sensors_applet->sensors), &sensor_iter_b, &sensor_iter_a);
            }
        }

        /* if a's if. and b's if is not the same
         * as b comes after a, b must be under a new if.
         * and so b must be the first node under that if. */
        /* set b to be the first sensor in the sensors tree, under the b's if. iter */
        if (-1 == ret_val) {

            /* this 'fails' if the tree is empty, but at least b is in it */
            gtk_tree_model_iter_children(GTK_TREE_MODEL(sensors_applet->sensors), &first_iter,  &interface_iter_b);

            /* we are only interested in the case, where the two are not equal
             * that means the b is not the first sensor */
            if ( 0 != sensors_applet_settings_sort_sensors_iter_compare (sensors_applet, first_iter, sensor_iter_b)) {

                /* it should be, so it needs to be moved to the first position */
                gtk_tree_store_move_after (GTK_TREE_STORE(sensors_applet->sensors), &sensor_iter_b, NULL);
            }

        }

        return 1;

    }

    /* hash_b has already been removed from the system */
    if (found_a && !found_b) {
        return 2;
    }

    /* this is the least likely case
     * if hash_a is not found, then the sensors-list starts with a sensor
     * that has already been removed from the system */
    if (!found_a) {
        return 3;
    }

    /* we should never get here */
    return 0;
}

/* sort sensors based on sensors-list array in gsettings */
gboolean sensors_applet_settings_sort_sensors (SensorsApplet *sensors_applet) {

    gchar **sensors_list = NULL;

    gchar *hash_a = NULL;
    gchar *hash_b = NULL;

    gint ret_val = -1;
    /* marks the first iteration */
    gint first_counter = 1;

    /* get sensors-list array from gsettings
     * newly allocated, has to be freed fully
     * for an empty array a pointer to a NULL pointer will be returned (g_variant_dup_strv ()) */
    sensors_list = g_settings_get_strv (sensors_applet->settings, "sensors-list");

    /* list is empty (on the first run) */
    if (NULL == *sensors_list) {
        /* still need to free the array, even if it is empty */
        g_strfreev (sensors_list);
        return FALSE;
    }

    gint i;
    /* hash lists are equal */
    gboolean hle = TRUE;
    /* compare saved sorted list to newly loaded sensors' list */
    for (i = 0; (NULL != sensors_applet->sensors_hash_array[i]) && (NULL != sensors_list[i]); i++) {

        if (g_ascii_strcasecmp(sensors_applet->sensors_hash_array[i], sensors_list[i]) != 0) {
            hle = FALSE;
            break;
        }
    }

    /* lists are the same -> nothing to do */
    if (hle) {
#ifdef SORT_DEBUG
        syslog(LOG_ERR, "sensor sort: saved list is the same as the new one, returning");
#endif

        /* still need to free the array */
        g_strfreev (sensors_list);
        return TRUE;
    }

#ifdef SORT_DEBUG
    sensors_applet_settings_print_sensors_tree (sensors_applet);
#endif


    for (i = 0; NULL != sensors_list[i]; i++) {

        /* first pass */
        if (i == 0) {
            /* make a copy */
            hash_a = g_strdup (sensors_list[i]);
            continue;
        }

        hash_b = g_strdup (sensors_list[i]);

        /* now that we have two hashes, find the two corresponding sensors and sort them
         * if i == 1, we have both a and b set, this is the first time calling this function */
        ret_val = sensors_applet_settings_sort_sensors_sort (sensors_applet, hash_a, hash_b, (i == first_counter));

        /* hash_b has already been removed from the system
         * don't free hash_a, don't reassign hash_b
         * as we already know that b is no longer in the system */
        if (2 == ret_val) {
            continue;
        }

        /* after sorting free hash_a (it should be in place) and reassign hash_b to hash_a */
        g_free (hash_a);
        hash_a = hash_b;

        /* hash_a not found
         * set hash_b as hash_a and set the first element counter
         * (essentially skip the first element in the sensors-list array) */
        if (3 == ret_val) {
            first_counter++;
        }
    }

#ifdef SORT_DEBUG
    sensors_applet_settings_print_sensors_tree (sensors_applet);
#endif

    /* hash_a already freed
     * only in the following case do we need to free it */
    if (2 == ret_val) {
        g_free (hash_a);
    }
    g_free (hash_b);

    g_strfreev (sensors_list);

    /* reorder active sensors based on reordered sensors tree */
    sensors_applet_reorder_sensors (sensors_applet);

    return TRUE;
}

/* save sensor data under a unique hash
 * save sensor sort in an array, with above hash */
gboolean sensors_applet_settings_save_sensors (SensorsApplet *sensors_applet) {

    /* write everything to GSettings except VISIBLE and ALARM_TIMEOUT_INDEX
     * for stepping through GtkTreeStore data structure */
    GtkTreeIter interfaces_iter;
    GtkTreeIter sensors_iter;
    gboolean not_end_of_interfaces = TRUE;
    gboolean not_end_of_sensors = TRUE;
    gchar *applet_path = NULL;

    gchar *current_path = NULL;
    gchar *current_id = NULL;
    gchar *current_label = NULL;
    gchar *current_interface = NULL;
    gchar *current_low_alarm_command = NULL;
    gchar *current_high_alarm_command = NULL;
    gchar *current_graph_color = NULL;
    gboolean current_enable,
             current_alarm_enable;
    gdouble current_low_value,
            current_high_value,
            current_multiplier,
            current_offset;
    guint current_alarm_timeout,
          current_sensor_type,
          current_icon_type;

    /* data structure (array) to be able to save sensors list to gsettings */
    GVariantBuilder builder;
    g_variant_builder_init (&builder, G_VARIANT_TYPE (GSGVTSA));

    applet_path = mate_panel_applet_get_preferences_path (sensors_applet->applet);

    /* now step through the GtkTreeStore sensors to find which sensors are available / loaded */
    for (not_end_of_interfaces = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(sensors_applet->sensors), &interfaces_iter);
        not_end_of_interfaces;
        not_end_of_interfaces = gtk_tree_model_iter_next(GTK_TREE_MODEL(sensors_applet->sensors), &interfaces_iter)) {


        for (not_end_of_sensors = gtk_tree_model_iter_children(GTK_TREE_MODEL(sensors_applet->sensors), &sensors_iter, &interfaces_iter);
            not_end_of_sensors;
            not_end_of_sensors = gtk_tree_model_iter_next(GTK_TREE_MODEL(sensors_applet->sensors), &sensors_iter)) {

            gtk_tree_model_get(GTK_TREE_MODEL(sensors_applet->sensors),
                               &sensors_iter,
                               PATH_COLUMN, &current_path,
                               ID_COLUMN, &current_id,
                               LABEL_COLUMN, &current_label,
                               INTERFACE_COLUMN, &current_interface,
                               SENSOR_TYPE_COLUMN, &current_sensor_type,
                               ENABLE_COLUMN, &current_enable,
                               LOW_VALUE_COLUMN, &current_low_value,
                               HIGH_VALUE_COLUMN, &current_high_value,
                               ALARM_ENABLE_COLUMN, &current_alarm_enable,
                               LOW_ALARM_COMMAND_COLUMN, &current_low_alarm_command,
                               HIGH_ALARM_COMMAND_COLUMN, &current_high_alarm_command,
                               ALARM_TIMEOUT_COLUMN, &current_alarm_timeout,
                               MULTIPLIER_COLUMN, &current_multiplier,
                               OFFSET_COLUMN, &current_offset,
                               ICON_TYPE_COLUMN, &current_icon_type,
                               GRAPH_COLOR_COLUMN, &current_graph_color,
                               -1);

            /* GSettings unique id for one sensor data */
            gchar *gsuid = sensors_applet_settings_get_unique_id (current_interface, current_id, current_path);

            /* save sensor uid to gvariant array */
            g_variant_builder_add(&builder,
                GSGVTS,       /* must be related to the G_VARIANT_TYPE in init and gsettings schema */
                gsuid);

            /* save sensor data to gsettings individually
             * g_strdup_printf doesn't free args!
             * applet_path is freed at the end */
            gchar *path = g_strdup_printf ("%s%s/", applet_path, gsuid);
            g_free (gsuid);

            GSettings *settings;
            settings = g_settings_new_with_path ("org.mate.sensors-applet.sensor", path);
            g_free (path);

            /* wait until g_settings_apply() is called to save all changes at once to gsettings */
            g_settings_delay (settings);
            g_settings_set_string (settings, PATH, current_path);
            g_settings_set_string (settings, ID, current_id);
            g_settings_set_string (settings, LABEL, current_label);
            g_settings_set_string (settings, INTERFACE, current_interface);
            g_settings_set_int (settings, SENSOR_TYPE, current_sensor_type);
            g_settings_set_boolean (settings, ENABLED, current_enable);
            g_settings_set_double (settings, LOW_VALUE, current_low_value);
            g_settings_set_double (settings, HIGH_VALUE, current_high_value);
            g_settings_set_boolean (settings, ALARM_ENABLED, current_alarm_enable);
            g_settings_set_string (settings, LOW_ALARM_COMMAND, current_low_alarm_command);
            g_settings_set_string (settings, HIGH_ALARM_COMMAND, current_high_alarm_command);
            g_settings_set_int (settings, ALARM_TIMEOUT, current_alarm_timeout);
            g_settings_set_double (settings, MULTIPLIER, current_multiplier);
            g_settings_set_double (settings, OFFSET, current_offset);
            g_settings_set_int (settings, ICON_TYPE, current_icon_type);
            g_settings_set_string (settings, GRAPH_COLOR, current_graph_color);
            g_settings_apply (settings);
            g_object_unref (settings);

        }
    }

    /* save the sensor-list array to gsettings
     * builder is freed by g_variant_builder_end()
     * the gvariant returned from g_variant_builder_end() is floating, so it is freed by g_settings_set_value() */
    g_settings_set_value (sensors_applet->settings, "sensors-list", g_variant_builder_end (&builder));

    g_free (applet_path);

    return TRUE;
}