fix save order of sensors v2

4 files changed, 496 insertions, 89 deletions

diff --git a/sensors-applet/sensors-applet-settings.c b/sensors-applet/sensors-applet-settings.c
index f6e1864..70dda3d 100644
--- a/sensors-applet/sensors-applet-settings.c
+++ b/sensors-applet/sensors-applet-settings.c
@@ -26,16 +26,22 @@
 #include "sensors-applet.h"
 #include "sensors-applet-settings.h"
 
-// these must be as the gsettings schema in file org.mate.sensors-applet.gschema.xml.in
-// gsettings gvariant type string
+/* #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
+/* 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;
-    gchar *unique_id_hash;
-    GChecksum *checksum;
+    gchar *unique_id = NULL;
+    gchar *unique_id_hash = NULL;
+    GChecksum *checksum = NULL;
     guint8 digest[16];
     gsize digest_len = sizeof (digest);
 
@@ -54,55 +60,53 @@ gchar* sensors_applet_settings_get_unique_id (const gchar *interface, const gcha
     return unique_id_hash;
 }
 
-
-/* gets called if are already setup so we don't have to manually go
-    through and find sensors etc again */
-gboolean sensors_applet_conf_setup_sensors(SensorsApplet *sensors_applet) {
+/* 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;
-    // not sure about pointer, it is unclear if it is freed by loop, probably yes
-    GVariantIter *iter;
-    gchar *gsuid;
-
-    // string variables, to help free up memory in loop
-    gchar *current_path,
-        *current_id,
-        *current_label,
-        *current_interface,
-        *current_low_alarm_command,
-        *current_high_alarm_command,
-        *current_graph_color;
-
-    // get gsettings path for applet
+    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
+    /* 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()
+    /* 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
+        /* 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
+        /*g_free (gsuid);   // freed by loop */
 
-        // make a schema which points to one sensor data
+        /* 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
+        /* 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),
@@ -138,23 +142,417 @@ gboolean sensors_applet_conf_setup_sensors(SensorsApplet *sensors_applet) {
     return TRUE;
 }
 
-// save sensor data under a unique hash
-// save sensor sort in an array, with above hash
+#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, sensors_iter;
-    gboolean not_end_of_interfaces = TRUE, not_end_of_sensors = TRUE;
-    gchar *applet_path;
-
-    int i;
-    gchar *current_path,
-          *current_id,
-          *current_label,
-          *current_interface,
-          *current_low_alarm_command,
-          *current_high_alarm_command,
-          *current_graph_color;
+
+    /* 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,
@@ -165,28 +563,19 @@ gboolean sensors_applet_settings_save_sensors (SensorsApplet *sensors_applet) {
           current_sensor_type,
           current_icon_type;
 
-    // data structure (array) to be able to save sensors list to gsettings
+    /* 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 enabled */
-    for (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(sensors_applet->sensors), &interfaces_iter);
+    /* 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)) {
 
-        gtk_tree_model_get(GTK_TREE_MODEL(sensors_applet->sensors),
-                           &interfaces_iter,
-                           ID_COLUMN, &current_id,
-                           -1);
-
-        g_free(current_id);
 
-        /* reset sensors sentinel */
-        not_end_of_sensors = TRUE;
-
-        for (gtk_tree_model_iter_children(GTK_TREE_MODEL(sensors_applet->sensors), &sensors_iter, &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)) {
 
@@ -210,17 +599,17 @@ gboolean sensors_applet_settings_save_sensors (SensorsApplet *sensors_applet) {
                                GRAPH_COLOR_COLUMN, &current_graph_color,
                                -1);
 
-            // GSettings unique id for one sensor data
+            /* 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
+            /* 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
-                g_strdup(gsuid));
+                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
+            /* 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);
 
@@ -228,7 +617,7 @@ gboolean sensors_applet_settings_save_sensors (SensorsApplet *sensors_applet) {
             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
+            /* 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);
@@ -252,15 +641,10 @@ gboolean sensors_applet_settings_save_sensors (SensorsApplet *sensors_applet) {
         }
     }
 
-    // save the sensor-list array to gsettings
-    GSettings *settings;
-    settings = g_settings_new_with_path ("org.mate.sensors-applet", applet_path);
-
-    // 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 (settings, "sensors-list", g_variant_builder_end (&builder));
-
-    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);
 
diff --git a/sensors-applet/sensors-applet-settings.h b/sensors-applet/sensors-applet-settings.h
index e1bcfb6..6bf3f7b 100644
--- a/sensors-applet/sensors-applet-settings.h
+++ b/sensors-applet/sensors-applet-settings.h
@@ -52,7 +52,8 @@
 #define GRAPH_COLOR           "graph-color"
 
 gchar* sensors_applet_settings_get_unique_id (const gchar *interface, const gchar *id, const gchar *path);
-gboolean sensors_applet_conf_setup_sensors (SensorsApplet *sensors_applet);
+gboolean sensors_applet_settings_load_sensors (SensorsApplet *sensors_applet);
+gboolean sensors_applet_settings_sort_sensors (SensorsApplet *sensors_applet);
 gboolean sensors_applet_settings_save_sensors (SensorsApplet *sensors_applet);
 
 #endif /* SENSORS_APPLET_SETTINGS_H*/
diff --git a/sensors-applet/sensors-applet.c b/sensors-applet/sensors-applet.c
index b85d1bf..e67a82d 100644
--- a/sensors-applet/sensors-applet.c
+++ b/sensors-applet/sensors-applet.c
@@ -51,6 +51,10 @@
 #define ROW_SPACING 1
 
 
+/* builder for sensor sorting verification */
+static GVariantBuilder gvb_sensors_hash_list;
+
+
 /* callbacks for panel menu */
 static void prefs_cb(GtkAction *action, gpointer *data) {
 
@@ -962,6 +966,10 @@ gboolean sensors_applet_add_sensor(SensorsApplet *sensors_applet,
     gchar *gsuid = sensors_applet_settings_get_unique_id (interface, id, path);
     gchar *settings_path = g_strdup_printf ("%s%s/", applet_path, gsuid);
     GSettings *settings = g_settings_new_with_path ("org.mate.sensors-applet.sensor", settings_path);
+
+    /* add hash to temp sorting list */
+    g_variant_builder_add (&gvb_sensors_hash_list, "s", gsuid);
+
     g_free (applet_path);
     g_free (gsuid);
     g_free (settings_path);
@@ -1255,12 +1263,25 @@ void sensors_applet_init(SensorsApplet *sensors_applet) {
     /* init gsettings */
     sensors_applet->settings = mate_panel_applet_settings_new (sensors_applet->applet, "org.mate.sensors-applet");
 
-    // load sensors from array saved in gsettings
-    sensors_applet_conf_setup_sensors(sensors_applet);
 
-    /* now do any setup needed manually */
+    /* set up builder for sorting verification */
+    g_variant_builder_init (&gvb_sensors_hash_list, G_VARIANT_TYPE ("as"));
+
+    /* set up / load sensors from the plugins */
     sensors_applet_plugins_load_all(sensors_applet);
 
+    /* set sorting hash array */
+    GVariant *gv_temp = g_variant_builder_end (&gvb_sensors_hash_list);
+    sensors_applet->sensors_hash_array = g_variant_dup_strv (gv_temp, NULL);
+    g_variant_unref (gv_temp);
+
+    /* sort sensors based on saved sorting */
+    sensors_applet_settings_sort_sensors(sensors_applet);
+
+    /* free hash array */
+    g_strfreev (sensors_applet->sensors_hash_array);
+
+
     /* should have created sensors tree above, but if have not was because we couldn't find any sensors */
     if (NULL == sensors_applet->sensors) {
         GtkWidget *label;
diff --git a/sensors-applet/sensors-applet.h b/sensors-applet/sensors-applet.h
index 4f44af1..7b3fb34 100644
--- a/sensors-applet/sensors-applet.h
+++ b/sensors-applet/sensors-applet.h
@@ -120,6 +120,7 @@ struct _SensorsApplet {
     gint size;
 
     GtkTreeStore *sensors;
+    gchar **sensors_hash_array;
     GtkTreeSelection *selection;
 
     GHashTable *required_plugins;