Fix indents 06

6 files changed, 740 insertions, 761 deletions

diff --git a/sensors-applet/about-dialog.c b/sensors-applet/about-dialog.c
index ef21ff2..9ffe856 100644
--- a/sensors-applet/about-dialog.c
+++ b/sensors-applet/about-dialog.c
@@ -35,7 +35,7 @@ void about_dialog_open(SensorsApplet *sensors_applet) {
     /* Construct the about dialog */
     gtk_show_about_dialog(NULL,
                   "icon-name", "mate-sensors-applet",
-                  "program-name", PACKAGE_NAME, 
+                  "program-name", PACKAGE_NAME,
                   "version", PACKAGE_VERSION,
                   "copyright", "(C) 2005-2009, Alex Murray <[email protected]>\n(C) 2011, Stefano Karapetsas <[email protected]>\n(C) 2012-2017, MATE developers",
                   "authors", authors,
diff --git a/sensors-applet/active-sensor-libnotify.c b/sensors-applet/active-sensor-libnotify.c
index a0a5981..ce0d07c 100644
--- a/sensors-applet/active-sensor-libnotify.c
+++ b/sensors-applet/active-sensor-libnotify.c
@@ -27,37 +27,36 @@
 #include "active-sensor-libnotify.h"
 
 static void notif_closed_cb(NotifyNotification *notification,
-                            ActiveSensor *active_sensor) 
-{
-        g_assert(notification != NULL && active_sensor != NULL);
-        
-        int i;
-        
-        g_debug("Notification was closed.. setting reference to NULL so we can show again if needed.");
-        
-        // set notif reference to NULL
-        for (i = 0; i < NUM_NOTIFS; i++) {
-                if (active_sensor->notification[i] == notification) {
-                        active_sensor->notification[i] = NULL;
-                        break;
-                }
+                            ActiveSensor *active_sensor) {
+
+    g_assert(notification != NULL && active_sensor != NULL);
+
+    int i;
+
+    g_debug("Notification was closed.. setting reference to NULL so we can show again if needed.");
+
+    // set notif reference to NULL
+    for (i = 0; i < NUM_NOTIFS; i++) {
+        if (active_sensor->notification[i] == notification) {
+            active_sensor->notification[i] = NULL;
+            break;
         }
+    }
 }
 
-                
 void active_sensor_libnotify_notify_end(ActiveSensor *active_sensor,
                                         NotifType notif_type) {
-        GError *error = NULL;
-        if (active_sensor->notification[notif_type]) {
-                g_debug("Closing notification");
-                if(!notify_notification_close(active_sensor->notification[notif_type],
-                                              &error)) {
-                        g_warning("Error closing notification: %s", error->message);
-                        g_error_free(error);
-                }
-                g_object_unref(active_sensor->notification[notif_type]);
-                active_sensor->notification[notif_type] = NULL;
+
+    GError *error = NULL;
+    if (active_sensor->notification[notif_type]) {
+        g_debug("Closing notification");
+        if(!notify_notification_close(active_sensor->notification[notif_type], &error)) {
+            g_warning("Error closing notification: %s", error->message);
+            g_error_free(error);
         }
+        g_object_unref(active_sensor->notification[notif_type]);
+        active_sensor->notification[notif_type] = NULL;
+    }
 }
 
 void active_sensor_libnotify_notify(ActiveSensor *active_sensor,
@@ -66,46 +65,39 @@ void active_sensor_libnotify_notify(ActiveSensor *active_sensor,
                                     const gchar *message,
                                     const gchar *icon_filename,
                                     gint timeout_msecs) {
-        GError *error = NULL;
 
-        if (!notify_is_initted()) {
-                if (!notify_init(PACKAGE)) {
-                        return;
-                }
-        }
-        g_debug("Doing notification %s: %s: %s", (notif_type == SENSOR_INTERFACE_ERROR ? "interface-error" : "other") ,summary, message);
+    GError *error = NULL;
 
-        /* leave any existing notification since most likely hasn't changed */
-        if (active_sensor->notification[notif_type] != NULL) {
-                return;
-/*                 active_sensor_libnotify_notify_end(active_sensor, notif_type); */
+    if (!notify_is_initted()) {
+        if (!notify_init(PACKAGE)) {
+            return;
         }
-
-        /* now create a new one */
-        g_debug("Creating new notification");
-        active_sensor->notification[notif_type] = notify_notification_new(summary,
-                                                                          message,
-                                                                          icon_filename);
-        g_signal_connect(active_sensor->notification[notif_type], "closed",
-                         G_CALLBACK(notif_closed_cb),
-                         active_sensor);
-
-        notify_notification_set_urgency(active_sensor->notification[notif_type],
-                                        NOTIFY_URGENCY_CRITICAL);
-        
-
-        /* timeout may have changed so update it */
-        notify_notification_set_timeout(active_sensor->notification[notif_type],
-                                        timeout_msecs);
-
-
-        g_debug("showing notification");
-        if (!notify_notification_show(active_sensor->notification[notif_type], &error)) {
-                g_debug("Error showing notification: %s", error->message);
-                g_error_free(error);
-        } 
-        
-
+    }
+    g_debug("Doing notification %s: %s: %s", (notif_type == SENSOR_INTERFACE_ERROR ? "interface-error" : "other") ,summary, message);
+
+    /* leave any existing notification since most likely hasn't changed */
+    if (active_sensor->notification[notif_type] != NULL) {
+        return;
+        /* active_sensor_libnotify_notify_end(active_sensor, notif_type); */
+    }
+
+    /* now create a new one */
+    g_debug("Creating new notification");
+    active_sensor->notification[notif_type] = notify_notification_new(summary, message, icon_filename);
+    g_signal_connect(active_sensor->notification[notif_type], "closed",
+                     G_CALLBACK(notif_closed_cb),
+                     active_sensor);
+
+    notify_notification_set_urgency(active_sensor->notification[notif_type], NOTIFY_URGENCY_CRITICAL);
+
+    /* timeout may have changed so update it */
+    notify_notification_set_timeout(active_sensor->notification[notif_type], timeout_msecs);
+
+    g_debug("showing notification");
+    if (!notify_notification_show(active_sensor->notification[notif_type], &error)) {
+        g_debug("Error showing notification: %s", error->message);
+        g_error_free(error);
+    }
 
 }
 
diff --git a/sensors-applet/active-sensor-libnotify.h b/sensors-applet/active-sensor-libnotify.h
index ceba9ae..b50117f 100644
--- a/sensors-applet/active-sensor-libnotify.h
+++ b/sensors-applet/active-sensor-libnotify.h
@@ -28,6 +28,7 @@ void active_sensor_libnotify_notify(ActiveSensor *active_sensor,
                                     const gchar *message,
                                     const gchar *icon_filename,
                                     gint timeout_msecs);
+
 void active_sensor_libnotify_notify_end(ActiveSensor *active_sensor,
                                         NotifType notif_type);
 
diff --git a/sensors-applet/active-sensor.c b/sensors-applet/active-sensor.c
index f4097a3..cf53dd2 100644
--- a/sensors-applet/active-sensor.c
+++ b/sensors-applet/active-sensor.c
@@ -34,11 +34,11 @@
 #include "sensors-applet-settings.h"
 
 typedef enum {
-        VERY_LOW_SENSOR_VALUE = 0,
-        LOW_SENSOR_VALUE,
-        NORMAL_SENSOR_VALUE,
-        HIGH_SENSOR_VALUE,
-        VERY_HIGH_SENSOR_VALUE
+    VERY_LOW_SENSOR_VALUE = 0,
+    LOW_SENSOR_VALUE,
+    NORMAL_SENSOR_VALUE,
+    HIGH_SENSOR_VALUE,
+    VERY_HIGH_SENSOR_VALUE
 } SensorValueRange;
 
 /* Cast a given value to a valid SensorValueRange */
@@ -47,140 +47,142 @@ typedef enum {
 #define CAIRO_GRAPH_COLOR_GRADIENT 0.4
 
 static const gchar * const temp_overlay_icons[] = {
-        PIXMAPS_DIR "very-low-temp-icon.png",
-        PIXMAPS_DIR "low-temp-icon.png",
-        PIXMAPS_DIR "normal-temp-icon.png",
-        PIXMAPS_DIR "high-temp-icon.png",
-        PIXMAPS_DIR "very-high-temp-icon.png"
+    PIXMAPS_DIR "very-low-temp-icon.png",
+    PIXMAPS_DIR "low-temp-icon.png",
+    PIXMAPS_DIR "normal-temp-icon.png",
+    PIXMAPS_DIR "high-temp-icon.png",
+    PIXMAPS_DIR "very-high-temp-icon.png"
 };
 
+
 static gdouble sensor_value_range_normalised(gdouble value,
                                           gdouble low_value,
                                           gdouble high_value) {
-        return ((value - low_value)/(high_value - low_value));
+
+    return ((value - low_value)/(high_value - low_value));
 }
 
 static SensorValueRange sensor_value_range(gdouble sensor_value,
-                                                            gdouble low_value,
-                                                            gdouble high_value) {
-        gdouble range;
-        range = sensor_value_range_normalised(sensor_value, low_value, high_value)*(gdouble)(VERY_HIGH_SENSOR_VALUE);
-
-        /* check if need to round up, otherwise let int conversion
-         * round down for us and make sure it is a valid range
-         * value */
-        return SENSOR_VALUE_RANGE(((gint)range + ((range - ((gint)range)) >= 0.5)));
-}
+                                            gdouble low_value,
+                                            gdouble high_value) {
 
+    gdouble range;
+    range = sensor_value_range_normalised(sensor_value, low_value, high_value)*(gdouble)(VERY_HIGH_SENSOR_VALUE);
+
+    /* check if need to round up, otherwise let int conversion
+     * round down for us and make sure it is a valid range
+     * value */
+    return SENSOR_VALUE_RANGE(((gint)range + ((range - ((gint)range)) >= 0.5)));
+}
 
 static gboolean active_sensor_execute_alarm(ActiveSensor *active_sensor,
                                             NotifType notif_type) {
-        gboolean ret;
-	GError *error = NULL;
 
-        sensors_applet_notify_active_sensor(active_sensor, notif_type);
-        g_debug("EXECUTING %s ALARM: %s", 
-                (notif_type == LOW_ALARM ? 
-                 "LOW" : "HIGH"),
-                active_sensor->alarm_command[notif_type]);
-	ret = g_spawn_command_line_async (active_sensor->alarm_command[notif_type], &error);
-        g_debug("Command executed in shell");
+    gboolean ret;
+    GError *error = NULL;
 
-	if (error)
-		g_error_free (error);
+    sensors_applet_notify_active_sensor(active_sensor, notif_type);
+    g_debug("EXECUTING %s ALARM: %s",
+            (notif_type == LOW_ALARM ?
+             "LOW" : "HIGH"),
+            active_sensor->alarm_command[notif_type]);
+    ret = g_spawn_command_line_async (active_sensor->alarm_command[notif_type], &error);
+    g_debug("Command executed in shell");
 
-        return ret;
+    if (error)
+        g_error_free (error);
+
+    return ret;
 }
 
 static gboolean active_sensor_execute_low_alarm(ActiveSensor *active_sensor) {
-        return active_sensor_execute_alarm(active_sensor, LOW_ALARM);
+    return active_sensor_execute_alarm(active_sensor, LOW_ALARM);
 }
 
 static gboolean active_sensor_execute_high_alarm(ActiveSensor *active_sensor) {
-        return active_sensor_execute_alarm(active_sensor, HIGH_ALARM);
+    return active_sensor_execute_alarm(active_sensor, HIGH_ALARM);
 }
 
-/* needs to be able to be called by the config dialog when the alarm
- * command changes */
+/* needs to be able to be called by the config dialog when the alarm command changes */
 void active_sensor_alarm_off(ActiveSensor *active_sensor,
                              NotifType notif_type) {
-	g_assert(active_sensor);
-
-	if (active_sensor->alarm_timeout_id[notif_type] != -1) {
-		g_debug("Disabling %s alarm.", 
-                        (notif_type == LOW_ALARM ? "LOW" : "HIGH"));
-		if (!g_source_remove(active_sensor->alarm_timeout_id[notif_type])) {
-			g_debug("Error removing alarm source");
-		}
-		g_free(active_sensor->alarm_command[notif_type]);
-		active_sensor->alarm_timeout_id[notif_type] = -1;
-
-	}
-        sensors_applet_notify_end(active_sensor, notif_type);
+
+    g_assert(active_sensor);
+
+    if (active_sensor->alarm_timeout_id[notif_type] != -1) {
+        g_debug("Disabling %s alarm.", (notif_type == LOW_ALARM ? "LOW" : "HIGH"));
+        if (!g_source_remove(active_sensor->alarm_timeout_id[notif_type])) {
+            g_debug("Error removing alarm source");
+        }
+        g_free(active_sensor->alarm_command[notif_type]);
+        active_sensor->alarm_timeout_id[notif_type] = -1;
+
+    }
+    sensors_applet_notify_end(active_sensor, notif_type);
 }
 
 static void active_sensor_all_alarms_off(ActiveSensor *active_sensor) {
-        /* turn off any alarms */
-        int i;
-        for (i = 0; i < NUM_ALARMS; i++) {
-                if (active_sensor->alarm_timeout_id[i] >= 0) {
-                        g_debug("-- turning off notif with type %d ---", i);
-                        active_sensor_alarm_off(active_sensor, i);
-                }
+    /* turn off any alarms */
+    int i;
+    for (i = 0; i < NUM_ALARMS; i++) {
+        if (active_sensor->alarm_timeout_id[i] >= 0) {
+            g_debug("-- turning off notif with type %d ---", i);
+            active_sensor_alarm_off(active_sensor, i);
         }
+    }
 }
 
 static void active_sensor_alarm_on(ActiveSensor *active_sensor,
                                    NotifType notif_type) {
-	GtkTreeModel *model;
-	GtkTreePath *tree_path;
-	GtkTreeIter iter;
-        
-	g_assert(active_sensor);
-
-	model = gtk_tree_row_reference_get_model(active_sensor->sensor_row);
-	tree_path = gtk_tree_row_reference_get_path(active_sensor->sensor_row);
-
-	if (gtk_tree_model_get_iter(model, &iter, tree_path)) {
-
-		if (active_sensor->alarm_timeout_id[notif_type] == -1) {
-			/* alarm is not currently on */			
-			gtk_tree_model_get(model,
-					   &iter,
-					   (notif_type == LOW_ALARM ? 
-                                            LOW_ALARM_COMMAND_COLUMN :
-                                            HIGH_ALARM_COMMAND_COLUMN), 
-                                           &(active_sensor->alarm_command[notif_type]),
-					   ALARM_TIMEOUT_COLUMN, &(active_sensor->alarm_timeout),
-					   -1);
-                        g_debug("Activating alarm to repeat every %d seconds", active_sensor->alarm_timeout);
-                        
-			/* execute alarm once, then add to time to
-			   keep repeating it */
-			active_sensor_execute_alarm(active_sensor, notif_type);
-                        int timeout = (active_sensor->alarm_timeout <= 0 ? 
-                                       G_MAXINT : 
-                                       active_sensor->alarm_timeout);
-                        switch (notif_type) {
-                        case LOW_ALARM:
-                                active_sensor->alarm_timeout_id[notif_type] = g_timeout_add_seconds(timeout,
-                                                                                                    (GSourceFunc)active_sensor_execute_low_alarm,
-                                                                                                    active_sensor);
-                                break;
-                        case HIGH_ALARM:
-                                active_sensor->alarm_timeout_id[notif_type] = g_timeout_add_seconds(timeout,
-                                                                                                    (GSourceFunc)active_sensor_execute_high_alarm,
-                                                                                                    active_sensor);
-                                break;
-                        default:
-                                g_debug("Unknown notif type: %d", notif_type);
-                        }
-                        
-                        
-                }
-	}
-	gtk_tree_path_free(tree_path);
-        
+
+    GtkTreeModel *model;
+    GtkTreePath *tree_path;
+    GtkTreeIter iter;
+
+    g_assert(active_sensor);
+
+    model = gtk_tree_row_reference_get_model(active_sensor->sensor_row);
+    tree_path = gtk_tree_row_reference_get_path(active_sensor->sensor_row);
+
+    if (gtk_tree_model_get_iter(model, &iter, tree_path)) {
+
+        if (active_sensor->alarm_timeout_id[notif_type] == -1) {
+            /* alarm is not currently on */
+            gtk_tree_model_get(model,
+                       &iter,
+                       (notif_type == LOW_ALARM ?
+                            LOW_ALARM_COMMAND_COLUMN :
+                            HIGH_ALARM_COMMAND_COLUMN),
+                       &(active_sensor->alarm_command[notif_type]),
+                       ALARM_TIMEOUT_COLUMN, &(active_sensor->alarm_timeout),
+                       -1);
+
+            g_debug("Activating alarm to repeat every %d seconds", active_sensor->alarm_timeout);
+
+            /* execute alarm once, then add to time to keep repeating it */
+            active_sensor_execute_alarm(active_sensor, notif_type);
+            int timeout = (active_sensor->alarm_timeout <= 0 ? G_MAXINT : active_sensor->alarm_timeout);
+            switch (notif_type) {
+                case LOW_ALARM:
+                    active_sensor->alarm_timeout_id[notif_type] = g_timeout_add_seconds(timeout,
+                                                                                        (GSourceFunc)active_sensor_execute_low_alarm,
+                                                                                        active_sensor);
+                    break;
+
+                case HIGH_ALARM:
+                    active_sensor->alarm_timeout_id[notif_type] = g_timeout_add_seconds(timeout,
+                                                                                        (GSourceFunc)active_sensor_execute_high_alarm,
+                                                                                        active_sensor);
+                    break;
+
+                default:
+                    g_debug("Unknown notif type: %d", notif_type);
+            }
+
+        }
+    }
+
+    gtk_tree_path_free(tree_path);
 }
 
 /**
@@ -188,625 +190,608 @@ static void active_sensor_alarm_on(ActiveSensor *active_sensor,
  * 0 if refer to same row, 1 if b comes before a
  */
 gint active_sensor_compare(ActiveSensor *a, ActiveSensor *b) {
-	GtkTreePath *a_tree_path, *b_tree_path;
-	gint ret_val;
+    GtkTreePath *a_tree_path, *b_tree_path;
+    gint ret_val;
 
-	g_assert(a);
-	g_assert(b);
+    g_assert(a);
+    g_assert(b);
 
-	a_tree_path = gtk_tree_row_reference_get_path(a->sensor_row);
-	b_tree_path = gtk_tree_row_reference_get_path(b->sensor_row);
+    a_tree_path = gtk_tree_row_reference_get_path(a->sensor_row);
+    b_tree_path = gtk_tree_row_reference_get_path(b->sensor_row);
 
-	ret_val = gtk_tree_path_compare(a_tree_path, b_tree_path);
+    ret_val = gtk_tree_path_compare(a_tree_path, b_tree_path);
 
-	gtk_tree_path_free(a_tree_path);
-	gtk_tree_path_free(b_tree_path);
+    gtk_tree_path_free(a_tree_path);
+    gtk_tree_path_free(b_tree_path);
 
-	return ret_val;
+    return ret_val;
 }
 
-static void active_sensor_update_icon(ActiveSensor *active_sensor, 
-                                      GdkPixbuf *base_icon, 
+static void active_sensor_update_icon(ActiveSensor *active_sensor,
+                                      GdkPixbuf *base_icon,
                                       SensorType sensor_type) {
 
-	GdkPixbuf *overlay_icon, *new_icon;
-	const gchar *overlay_icon_filename = NULL;
-        SensorValueRange value_range;
-
-	g_assert(active_sensor);
-
-	/* select overlay icon
-	 * depending on sensor
-	 * value */
-        value_range = sensor_value_range(active_sensor->sensor_values[0],
-                                         active_sensor->sensor_low_value,
-                                         active_sensor->sensor_high_value);
-
-        if (sensor_type == TEMP_SENSOR) {
-                overlay_icon_filename = temp_overlay_icons[value_range];
-        } 
-
-	/* load base icon */
-	new_icon = gdk_pixbuf_copy(base_icon);
-
-	/* only load overlay if required */
-	if (overlay_icon_filename) {
-		overlay_icon = gdk_pixbuf_new_from_file_at_size(overlay_icon_filename,
-								DEFAULT_ICON_SIZE, 
-								DEFAULT_ICON_SIZE,
-								NULL);
-		if (overlay_icon) {
-			gdk_pixbuf_composite(overlay_icon, new_icon,
-					     0, 0,
-					     DEFAULT_ICON_SIZE, DEFAULT_ICON_SIZE,
-					     0, 0,
-					     1.0, 1.0,
-					     GDK_INTERP_BILINEAR,
-					     255);
-			
-			g_object_unref(overlay_icon);
-		}
-	}
-        gtk_image_set_from_pixbuf(GTK_IMAGE(active_sensor->icon),
-                                  new_icon);
-	g_object_unref(new_icon);
-	
+    GdkPixbuf *overlay_icon, *new_icon;
+    const gchar *overlay_icon_filename = NULL;
+    SensorValueRange value_range;
+
+    g_assert(active_sensor);
+
+    /* select overlay icon depending on sensor value */
+    value_range = sensor_value_range(active_sensor->sensor_values[0],
+                                     active_sensor->sensor_low_value,
+                                     active_sensor->sensor_high_value);
+
+    if (sensor_type == TEMP_SENSOR) {
+        overlay_icon_filename = temp_overlay_icons[value_range];
+    }
+
+    /* load base icon */
+    new_icon = gdk_pixbuf_copy(base_icon);
+
+    /* only load overlay if required */
+    if (overlay_icon_filename) {
+        overlay_icon = gdk_pixbuf_new_from_file_at_size(overlay_icon_filename,
+                                DEFAULT_ICON_SIZE,
+                                DEFAULT_ICON_SIZE,
+                                NULL);
+
+        if (overlay_icon) {
+            gdk_pixbuf_composite(overlay_icon, new_icon,
+                                 0, 0,
+                                 DEFAULT_ICON_SIZE, DEFAULT_ICON_SIZE,
+                                 0, 0,
+                                 1.0, 1.0,
+                                 GDK_INTERP_BILINEAR,
+                                 255);
+
+            g_object_unref(overlay_icon);
+        }
+    }
+
+    gtk_image_set_from_pixbuf(GTK_IMAGE(active_sensor->icon),
+                              new_icon);
+    g_object_unref(new_icon);
+
 }
 
 static void active_sensor_update_graph(ActiveSensor *as, cairo_t *cr) {
-        GtkAllocation allocation;
-        gdouble line_height;
-        gdouble width, height;
-        gdouble x, y;
-        cairo_pattern_t *pattern;
-        gint i;
-
-        gtk_widget_get_allocation (as->graph, &allocation);
-        width = allocation.width;
-        height = allocation.height;
-
-        /* so we can set a clipping area, as well as fill the
-         * back of the graph black */
-        cairo_rectangle(cr,
-                        0, 0,
-                        width,
-                        height);
-        /* clip to rectangle and keep it as a path so can be
-         * filled below */
-        cairo_clip_preserve(cr);
-
-        /* use black for bg color of graphs */
-        cairo_set_source_rgb(cr, 0.0, 0.0, 0.0);
-        cairo_fill(cr);
-        
-
-        /* determine height to scale line at for each value -
-         * only do as many as will fit or the number of
-         * samples that we have */
-        for (i = 0; i < MIN(as->num_samples, width); i++) {
-                /* need to remove one more to make it line up
-                 * properly  when drawing */
-                x = width - i - 1;
-                y = height;
-
-                line_height = sensor_value_range_normalised(as->sensor_values[i],
-                                                            as->sensor_low_value,
-                                                            as->sensor_high_value) * height;
-                
-                
-                
-                if (line_height > 0) { 
-                        cairo_move_to(cr,
-                                      x, 
-                                      y);
-                        cairo_line_to(cr, x, 
-                                      y - line_height);
-                }
-
+    GtkAllocation allocation;
+    gdouble line_height;
+    gdouble width, height;
+    gdouble x, y;
+    cairo_pattern_t *pattern;
+    gint i;
+
+    gtk_widget_get_allocation (as->graph, &allocation);
+    width = allocation.width;
+    height = allocation.height;
+
+    /* so we can set a clipping area, as well as fill the * back of the graph black */
+    cairo_rectangle(cr,
+                    0, 0,
+                    width,
+                    height);
+    /* clip to rectangle and keep it as a path so can be
+     * filled below */
+    cairo_clip_preserve(cr);
+
+    /* use black for bg color of graphs */
+    cairo_set_source_rgb(cr, 0.0, 0.0, 0.0);
+    cairo_fill(cr);
+
+    /* determine height to scale line at for each value -
+     * only do as many as will fit or the number of
+     * samples that we have */
+    for (i = 0; i < MIN(as->num_samples, width); i++) {
+        /* need to remove one more to make it line up
+         * properly  when drawing */
+        x = width - i - 1;
+        y = height;
+
+        line_height = sensor_value_range_normalised(as->sensor_values[i],
+                                                    as->sensor_low_value,
+                                                    as->sensor_high_value) * height;
+
+        if (line_height > 0) {
+            cairo_move_to(cr, x, y);
+            cairo_line_to(cr, x, y - line_height);
         }
-        /* make lines a gradient from slightly darker than
-         * chosen color at bottom of graph, to slightly
-         * lighter than chosen color at top of graph */
-        pattern = cairo_pattern_create_linear(x, y,
-                                              x, 0);
-        cairo_pattern_add_color_stop_rgb(pattern,
-                                         0,
-                                         as->graph_color.red - CAIRO_GRAPH_COLOR_GRADIENT, 
-                                         as->graph_color.green - CAIRO_GRAPH_COLOR_GRADIENT, 
-                                         as->graph_color.blue - CAIRO_GRAPH_COLOR_GRADIENT);
-
-        cairo_pattern_add_color_stop_rgb(pattern,
-                                         height,
-                                         as->graph_color.red + CAIRO_GRAPH_COLOR_GRADIENT, 
-                                         as->graph_color.green + CAIRO_GRAPH_COLOR_GRADIENT, 
-                                         as->graph_color.blue + CAIRO_GRAPH_COLOR_GRADIENT);
-
-        cairo_set_source(cr, pattern);
-        cairo_stroke(cr);
-        cairo_pattern_destroy(pattern);
+    }
+
+    /* make lines a gradient from slightly darker than
+     * chosen color at bottom of graph, to slightly
+     * lighter than chosen color at top of graph */
+    pattern = cairo_pattern_create_linear(x, y, x, 0);
+    cairo_pattern_add_color_stop_rgb(pattern,
+                                     0,
+                                     as->graph_color.red - CAIRO_GRAPH_COLOR_GRADIENT,
+                                     as->graph_color.green - CAIRO_GRAPH_COLOR_GRADIENT,
+                                     as->graph_color.blue - CAIRO_GRAPH_COLOR_GRADIENT);
+
+    cairo_pattern_add_color_stop_rgb(pattern,
+                                     height,
+                                     as->graph_color.red + CAIRO_GRAPH_COLOR_GRADIENT,
+                                     as->graph_color.green + CAIRO_GRAPH_COLOR_GRADIENT,
+                                     as->graph_color.blue + CAIRO_GRAPH_COLOR_GRADIENT);
+
+    cairo_set_source(cr, pattern);
+    cairo_stroke(cr);
+    cairo_pattern_destroy(pattern);
 }
 
 void active_sensor_destroy(ActiveSensor *active_sensor) {
-        g_debug("-- destroying active sensor label...");
-        gtk_widget_destroy(active_sensor->label);
+    g_debug("-- destroying active sensor label...");
+    gtk_widget_destroy(active_sensor->label);
 
-        g_debug("-- destroying active sensor icon..");
-        gtk_widget_destroy(active_sensor->icon);
+    g_debug("-- destroying active sensor icon..");
+    gtk_widget_destroy(active_sensor->icon);
 
-        g_debug("-- destroying active sensor value...");
-        gtk_widget_destroy(active_sensor->value);
+    g_debug("-- destroying active sensor value...");
+    gtk_widget_destroy(active_sensor->value);
 
-        g_debug("-- destroying active sensor graph and frame...");
-        gtk_widget_destroy(active_sensor->graph);
-        gtk_widget_destroy(active_sensor->graph_frame);
+    g_debug("-- destroying active sensor graph and frame...");
+    gtk_widget_destroy(active_sensor->graph);
+    gtk_widget_destroy(active_sensor->graph_frame);
 
-        g_debug("-- destroying active sensor values...");
-        g_free(active_sensor->sensor_values);
+    g_debug("-- destroying active sensor values...");
+    g_free(active_sensor->sensor_values);
 
-        active_sensor_all_alarms_off(active_sensor);
+    active_sensor_all_alarms_off(active_sensor);
 
-        g_free(active_sensor);
+    g_free(active_sensor);
 }
 
 gboolean graph_draw_cb(GtkWidget *graph,
                        cairo_t *cr,
                        gpointer data) {
-        ActiveSensor *as;
 
-        as = (ActiveSensor *)data;
+    ActiveSensor *as;
+
+    as = (ActiveSensor *)data;
 
-        active_sensor_update_graph(as, cr);
-        /* propagate event onwards */
+    active_sensor_update_graph(as, cr);
+    /* propagate event onwards */
 
-        return FALSE;
+    return FALSE;
 }
 
 static void active_sensor_set_graph_dimensions(ActiveSensor *as,
                                                gint width,
                                                gint height) {
-        gdouble *old_values;
-        gint num_samples, old_num_samples;
-        gint graph_width, graph_height;
-
-        /* dimensions are really for graph frame, so need to remove
-         * extra width added by graph frame - make sure not less than
-         * 1 - always need atleast 1 sample */
-        graph_width = CLAMP(width - GRAPH_FRAME_EXTRA_WIDTH, 1, width - GRAPH_FRAME_EXTRA_WIDTH);
-        graph_height = CLAMP(height - GRAPH_FRAME_EXTRA_WIDTH, 1 , height - GRAPH_FRAME_EXTRA_WIDTH);
-
-        g_debug("setting graph dimensions to %d x %d", graph_width, graph_height);
-        num_samples = graph_width;
-
-        if (as->sensor_values) {
-                old_values = as->sensor_values;
-                old_num_samples = as->num_samples;
-                
-                as->num_samples = num_samples;
-                as->sensor_values = g_malloc0(sizeof(gdouble)*as->num_samples);
-                memcpy(as->sensor_values,
-                       old_values,
-                       MIN(old_num_samples, as->num_samples)*sizeof(gdouble));
-
-                g_free(old_values);
-        } else {
-                as->sensor_values = g_malloc0(sizeof(gdouble)*num_samples);
-                as->num_samples = num_samples;
-        }                
-
-        /* update graph frame size request */
-        gtk_widget_set_size_request(as->graph,
-                                    graph_width, 
-                                    graph_height);
+
+    gdouble *old_values;
+    gint num_samples, old_num_samples;
+    gint graph_width, graph_height;
+
+    /* dimensions are really for graph frame, so need to remove
+     * extra width added by graph frame - make sure not less than
+     * 1 - always need atleast 1 sample */
+    graph_width = CLAMP(width - GRAPH_FRAME_EXTRA_WIDTH, 1, width - GRAPH_FRAME_EXTRA_WIDTH);
+    graph_height = CLAMP(height - GRAPH_FRAME_EXTRA_WIDTH, 1 , height - GRAPH_FRAME_EXTRA_WIDTH);
+
+    g_debug("setting graph dimensions to %d x %d", graph_width, graph_height);
+    num_samples = graph_width;
+
+    if (as->sensor_values) {
+        old_values = as->sensor_values;
+        old_num_samples = as->num_samples;
+
+        as->num_samples = num_samples;
+        as->sensor_values = g_malloc0(sizeof(gdouble)*as->num_samples);
+        memcpy(as->sensor_values,
+               old_values,
+               MIN(old_num_samples, as->num_samples)*sizeof(gdouble));
+
+        g_free(old_values);
+    } else {
+        as->sensor_values = g_malloc0(sizeof(gdouble)*num_samples);
+        as->num_samples = num_samples;
+    }
+
+    /* update graph frame size request */
+    gtk_widget_set_size_request(as->graph,
+                                graph_width,
+                                graph_height);
 }
 
 void active_sensor_update_graph_dimensions(ActiveSensor *as,
                                      gint sizes[2]) {
-        active_sensor_set_graph_dimensions(as, sizes[0], sizes[1]);
-        gtk_widget_queue_draw (as->graph);
+
+    active_sensor_set_graph_dimensions(as, sizes[0], sizes[1]);
+    gtk_widget_queue_draw (as->graph);
 }
 
 ActiveSensor *active_sensor_new(SensorsApplet *sensors_applet,
                                 GtkTreeRowReference *sensor_row) {
-        ActiveSensor *active_sensor;
-        MatePanelAppletOrient orient;
-        gint graph_size;
-        gboolean horizontal;
 
-        g_assert(sensors_applet);
-        g_assert(sensor_row);
+    ActiveSensor *active_sensor;
+    MatePanelAppletOrient orient;
+    gint graph_size;
+    gboolean horizontal;
 
-        g_debug("creating new active sensor");
+    g_assert(sensors_applet);
+    g_assert(sensor_row);
 
-	active_sensor = g_new0(ActiveSensor, 1);
-        active_sensor->sensors_applet = sensors_applet;
+    g_debug("creating new active sensor");
 
-	active_sensor->sensor_row = sensor_row;
+    active_sensor = g_new0(ActiveSensor, 1);
+    active_sensor->sensors_applet = sensors_applet;
 
-        int i;
-        for (i = 0; i < NUM_NOTIFS; i++) {
-                active_sensor->alarm_timeout_id[i] = -1;
-        }
+    active_sensor->sensor_row = sensor_row;
+
+    int i;
+    for (i = 0; i < NUM_NOTIFS; i++) {
+        active_sensor->alarm_timeout_id[i] = -1;
+    }
 
-        active_sensor->label = gtk_label_new("");
-        active_sensor->value = gtk_label_new("");
-        active_sensor->icon = gtk_image_new();
-
-        active_sensor->graph = gtk_drawing_area_new();
-        active_sensor->graph_frame = gtk_frame_new(NULL);
-        gtk_frame_set_shadow_type(GTK_FRAME(active_sensor->graph_frame),
-                                  GTK_SHADOW_IN);
-        gtk_container_add(GTK_CONTAINER(active_sensor->graph_frame),
-                          active_sensor->graph);
-        gtk_widget_add_events(active_sensor->graph_frame,
-                              GDK_ALL_EVENTS_MASK);
-
-        /* need to set size according to orientation */
-        orient = mate_panel_applet_get_orient(active_sensor->sensors_applet->applet);
-        graph_size = g_settings_get_int(active_sensor->sensors_applet->settings, GRAPH_SIZE);
-
-        horizontal = ((orient == MATE_PANEL_APPLET_ORIENT_UP) ||
-                      (orient == MATE_PANEL_APPLET_ORIENT_DOWN));
-
-        active_sensor_set_graph_dimensions(active_sensor,
-                                           (horizontal ? graph_size : sensors_applet->size),
-                                           (horizontal ? sensors_applet->size : graph_size));
-
-        g_signal_connect(G_OBJECT(active_sensor->graph),
-                         "draw",
-                         G_CALLBACK(graph_draw_cb),
-                         active_sensor);
-
-        active_sensor->updated = FALSE;
-        return active_sensor;
+    active_sensor->label = gtk_label_new("");
+    active_sensor->value = gtk_label_new("");
+    active_sensor->icon = gtk_image_new();
+
+    active_sensor->graph = gtk_drawing_area_new();
+    active_sensor->graph_frame = gtk_frame_new(NULL);
+    gtk_frame_set_shadow_type(GTK_FRAME(active_sensor->graph_frame),
+                              GTK_SHADOW_IN);
+    gtk_container_add(GTK_CONTAINER(active_sensor->graph_frame),
+                      active_sensor->graph);
+    gtk_widget_add_events(active_sensor->graph_frame,
+                          GDK_ALL_EVENTS_MASK);
+
+    /* need to set size according to orientation */
+    orient = mate_panel_applet_get_orient(active_sensor->sensors_applet->applet);
+    graph_size = g_settings_get_int(active_sensor->sensors_applet->settings, GRAPH_SIZE);
+
+    horizontal = ((orient == MATE_PANEL_APPLET_ORIENT_UP) ||
+                  (orient == MATE_PANEL_APPLET_ORIENT_DOWN));
+
+    active_sensor_set_graph_dimensions(active_sensor,
+                                       (horizontal ? graph_size : sensors_applet->size),
+                                       (horizontal ? sensors_applet->size : graph_size));
+
+    g_signal_connect(G_OBJECT(active_sensor->graph),
+                     "draw",
+                     G_CALLBACK(graph_draw_cb),
+                     active_sensor);
+
+    active_sensor->updated = FALSE;
+    return active_sensor;
 }
 
 static void active_sensor_update_sensor_value(ActiveSensor *as,
                                               gdouble sensor_value) {
 
-        /* only if have more than 1 sample stored */
-        if (as->num_samples > 1) {
-                memmove(&(as->sensor_values[1]),
-                        as->sensor_values,
-                        (as->num_samples - 1)*sizeof(gdouble));
-        }
-        
-        as->sensor_values[0] = sensor_value;
+    /* only if have more than 1 sample stored */
+    if (as->num_samples > 1) {
+        memmove(&(as->sensor_values[1]),
+                as->sensor_values,
+                (as->num_samples - 1)*sizeof(gdouble));
+    }
+
+    as->sensor_values[0] = sensor_value;
 }
 
-void active_sensor_update(ActiveSensor *active_sensor, 
+void active_sensor_update(ActiveSensor *active_sensor,
                           SensorsApplet *sensors_applet) {
 
-        GtkTreeModel *model;
-	GtkTreeIter iter;
-	GtkTreePath *path;
-
-	/* instance data from the tree for this sensor */
-	gchar *sensor_path = NULL;
-	gchar *sensor_id = NULL;
-	gchar *sensor_label = NULL;
-	SensorType sensor_type;
-	gchar *sensor_interface;
-	gboolean sensor_enabled;
-	gdouble sensor_low_value;
-	gdouble sensor_high_value;
-	gboolean sensor_alarm_enabled;
-	gdouble sensor_multiplier;
-	gdouble sensor_offset;
-	gdouble sensor_value;
-	GdkPixbuf *icon_pixbuf;
-	gchar *graph_color;
-	gint label_min_width;
-	gint label_width;
-	GtkRequisition  req;
-
-	/* to build the list of labels as we go */
-	gchar *value_text = NULL;
-	gchar *old_value_text;
-
-        TemperatureScale scale;
-        DisplayMode display_mode;
-
-	GError *error = NULL;
-
-        gchar *tooltip = NULL;
-        gchar *value_tooltip = NULL;
-
-        /* hidden gsettings options */
-        gint font_size = 0;
-        gboolean hide_units = FALSE;
-        gboolean hide_units_old = FALSE;
-
-	g_assert(active_sensor);
-	g_assert(active_sensor->sensor_row);
-        g_assert(sensors_applet);
-
-	model = gtk_tree_row_reference_get_model(active_sensor->sensor_row);
-	path = gtk_tree_row_reference_get_path(active_sensor->sensor_row);
-
-	/* if can successfully get iter can proceed */
-	if (gtk_tree_model_get_iter(model, &iter, path)) {
-		gtk_tree_path_free(path);
-		gtk_tree_model_get(GTK_TREE_MODEL(sensors_applet->sensors), 
-				   &iter,
-				   PATH_COLUMN, &sensor_path,
-				   ID_COLUMN, &sensor_id,
-				   LABEL_COLUMN, &sensor_label,
-				   INTERFACE_COLUMN, &sensor_interface,
-				   SENSOR_TYPE_COLUMN, &sensor_type,
-				   ENABLE_COLUMN, &sensor_enabled,
-				   LOW_VALUE_COLUMN, &sensor_low_value,
-				   HIGH_VALUE_COLUMN, &sensor_high_value,
-				   ALARM_ENABLE_COLUMN, &sensor_alarm_enabled,
-				   MULTIPLIER_COLUMN, &sensor_multiplier,
-				   OFFSET_COLUMN, &sensor_offset,
-                                   ICON_PIXBUF_COLUMN, &icon_pixbuf,
-                                   GRAPH_COLOR_COLUMN, &graph_color,
-				   -1);
-			
-
-                SensorsAppletPluginGetSensorValue get_sensor_value;
-		/* only call function if is in hash table for plugin */
-                if ((get_sensor_value = sensors_applet_plugins_get_sensor_value_func(sensors_applet, sensor_interface)) != NULL) {
-                        sensor_value = get_sensor_value(sensor_path,
-                                                        sensor_id,
-                                                        sensor_type,
-                                                        &error);
-				
-
-                        if (error) {
-                                g_debug("Error updating active sensor: %s", error->message);
-                                sensors_applet_notify_active_sensor(active_sensor, 
-                                                                    SENSOR_INTERFACE_ERROR);
-                                
-                                /* hard code text as ERROR */
-				value_text = g_strdup(_("ERROR"));
-                                value_tooltip = g_strdup_printf("- %s", error->message);
-				g_error_free(error);
-				error = NULL;
-
-                                /* set sensor value to an error code -
-                                 * note this is not unique */
-                                sensor_value = -1;
-			} else { 
-                                /* use hidden gsettings key for hide_units */
-				hide_units_old = hide_units;
-				hide_units = g_settings_get_boolean(sensors_applet->settings, HIDE_UNITS);
-
-                                /* scale value and set text using this
-                                 * value */
-				switch (sensor_type) {
-				case TEMP_SENSOR:
-
-                                        scale = (TemperatureScale) g_settings_get_int(sensors_applet->settings, TEMPERATURE_SCALE);
-                                        /* scale value */
-					sensor_value = sensors_applet_convert_temperature(sensor_value, 
-                                                                                          CELSIUS,
-                                                                                          scale); 
-                                        
-                                        sensor_value = (sensor_value * sensor_multiplier) + sensor_offset;
-                                        switch (scale) {
-                                        case FAHRENHEIT:
-                                                value_text = g_strdup_printf("%2.0f %s", sensor_value, (hide_units ? "" : UNITS_FAHRENHEIT));
-                                                /* tooltip should
-                                                 * always display
-                                                 * units */
-                                                value_tooltip = g_strdup_printf("%2.0f %s", sensor_value, UNITS_FAHRENHEIT);
-                                                
-                                                break;
-                                        case CELSIUS:
-                                                value_text = g_strdup_printf("%2.0f %s", sensor_value, (hide_units ? "" : UNITS_CELSIUS));
-                                                value_tooltip = g_strdup_printf("%2.0f %s", sensor_value, UNITS_CELSIUS);
-                                                break;
-                                        case KELVIN:
-                                                value_text = g_strdup_printf("%2.0f", sensor_value);
-                                                value_tooltip = g_strdup(value_text);
-                                                break;
-                                        }
-                                        break;
-				
-                                case FAN_SENSOR:
-                                        sensor_value = (sensor_value * sensor_multiplier) + sensor_offset;
-                                        value_text = g_strdup_printf("%4.0f %s", sensor_value, (hide_units ? "" : UNITS_RPM));
-                                        value_tooltip = g_strdup_printf("%4.0f %s", sensor_value, UNITS_RPM);
-
-					break;
-                                        
-				case VOLTAGE_SENSOR:
-					sensor_value = (sensor_value * sensor_multiplier) + sensor_offset;
-					value_text = g_strdup_printf("%4.2f %s", sensor_value, (hide_units ? "" : UNITS_VOLTAGE));
-					value_tooltip = g_strdup_printf("%4.2f %s", sensor_value, UNITS_VOLTAGE);
-
-					break;
-				
-				case CURRENT_SENSOR:
-					sensor_value = (sensor_value * sensor_multiplier) + sensor_offset;
-					value_text = g_strdup_printf("%4.2f %s", sensor_value, (hide_units ? "" : UNITS_CURRENT));
-					value_tooltip = g_strdup_printf("%4.2f %s", sensor_value, UNITS_CURRENT);
-					break;
-				
-                                } /* end switch(sensor_type) */
-                        } /* end else on error */
-
-                        /* setup for tooltips */
-                        if (sensors_applet->show_tooltip)
-                                tooltip = g_strdup_printf("%s %s", sensor_label, value_tooltip);
-                        g_free(value_tooltip);
-
-                        /* only do icons and labels / graphs if needed */
-                        display_mode = g_settings_get_int (sensors_applet->settings, DISPLAY_MODE);
-                        
-                        /* most users wont have a font size set */
-                        font_size = g_settings_get_int (sensors_applet->settings, FONT_SIZE);
-
-                                                
-                        /* do icon if needed */
-                        if (display_mode == DISPLAY_ICON ||
-                            display_mode == DISPLAY_ICON_WITH_VALUE) {
-                                /* update icon if icon range has changed if no
-                                 * update has been done before */
-                                if ((sensor_value_range(sensor_value, sensor_low_value, sensor_high_value) != sensor_value_range(active_sensor->sensor_values[0], active_sensor->sensor_low_value, active_sensor->sensor_high_value)) || !(active_sensor->updated)) {
-                                        active_sensor_update_sensor_value(active_sensor,
-                                                                          sensor_value);
-                                        active_sensor->sensor_low_value = sensor_low_value;
-                                        active_sensor->sensor_high_value = sensor_high_value;                                
-                                        active_sensor_update_icon(active_sensor, icon_pixbuf, sensor_type);
-                                }
-                                if (tooltip) {
-                                        gtk_widget_set_tooltip_text(active_sensor->icon,
-                                                                    tooltip);
-                                }
-                        }
-                        active_sensor_update_sensor_value(active_sensor,
-                                                          sensor_value);
-                        active_sensor->sensor_low_value = sensor_low_value;
-                        active_sensor->sensor_high_value = sensor_high_value;
-                
-                        /* do graph if needed */
-                        if (display_mode == DISPLAY_GRAPH) {
-                                /* update graph color in case has changed */
-                                gdk_rgba_parse(&(active_sensor->graph_color),
-                                               graph_color);
-                                
-                                gtk_widget_queue_draw (active_sensor->graph);
-                                if (tooltip) {
-                                        gtk_widget_set_tooltip_text(active_sensor->graph,
-                                                                    tooltip);
-                                }
-                                
+    GtkTreeModel *model;
+    GtkTreeIter iter;
+    GtkTreePath *path;
+
+    /* instance data from the tree for this sensor */
+    gchar *sensor_path = NULL;
+    gchar *sensor_id = NULL;
+    gchar *sensor_label = NULL;
+    SensorType sensor_type;
+    gchar *sensor_interface;
+    gboolean sensor_enabled;
+    gdouble sensor_low_value;
+    gdouble sensor_high_value;
+    gboolean sensor_alarm_enabled;
+    gdouble sensor_multiplier;
+    gdouble sensor_offset;
+    gdouble sensor_value;
+    GdkPixbuf *icon_pixbuf;
+    gchar *graph_color;
+    gint label_min_width;
+    gint label_width;
+    GtkRequisition  req;
+
+    /* to build the list of labels as we go */
+    gchar *value_text = NULL;
+    gchar *old_value_text;
+
+    TemperatureScale scale;
+    DisplayMode display_mode;
+
+    GError *error = NULL;
+
+    gchar *tooltip = NULL;
+    gchar *value_tooltip = NULL;
+
+    /* hidden gsettings options */
+    gint font_size = 0;
+    gboolean hide_units = FALSE;
+    gboolean hide_units_old = FALSE;
+
+    g_assert(active_sensor);
+    g_assert(active_sensor->sensor_row);
+    g_assert(sensors_applet);
+
+    model = gtk_tree_row_reference_get_model(active_sensor->sensor_row);
+    path = gtk_tree_row_reference_get_path(active_sensor->sensor_row);
+
+    /* if can successfully get iter can proceed */
+    if (gtk_tree_model_get_iter(model, &iter, path)) {
+        gtk_tree_path_free(path);
+        gtk_tree_model_get(GTK_TREE_MODEL(sensors_applet->sensors),
+                   &iter,
+                   PATH_COLUMN, &sensor_path,
+                   ID_COLUMN, &sensor_id,
+                   LABEL_COLUMN, &sensor_label,
+                   INTERFACE_COLUMN, &sensor_interface,
+                   SENSOR_TYPE_COLUMN, &sensor_type,
+                   ENABLE_COLUMN, &sensor_enabled,
+                   LOW_VALUE_COLUMN, &sensor_low_value,
+                   HIGH_VALUE_COLUMN, &sensor_high_value,
+                   ALARM_ENABLE_COLUMN, &sensor_alarm_enabled,
+                   MULTIPLIER_COLUMN, &sensor_multiplier,
+                   OFFSET_COLUMN, &sensor_offset,
+                   ICON_PIXBUF_COLUMN, &icon_pixbuf,
+                   GRAPH_COLOR_COLUMN, &graph_color,
+                   -1);
+
+        SensorsAppletPluginGetSensorValue get_sensor_value;
+        /* only call function if is in hash table for plugin */
+        if ((get_sensor_value = sensors_applet_plugins_get_sensor_value_func(sensors_applet, sensor_interface)) != NULL) {
+            sensor_value = get_sensor_value(sensor_path,
+                                            sensor_id,
+                                            sensor_type,
+                                            &error);
+
+            if (error) {
+                g_debug("Error updating active sensor: %s", error->message);
+                sensors_applet_notify_active_sensor(active_sensor,
+                                                    SENSOR_INTERFACE_ERROR);
+
+                /* hard code text as ERROR */
+                value_text = g_strdup(_("ERROR"));
+                value_tooltip = g_strdup_printf("- %s", error->message);
+                g_error_free(error);
+                error = NULL;
+
+                /* set sensor value to an error code -
+                 * note this is not unique */
+                sensor_value = -1;
+            } else {
+                /* use hidden gsettings key for hide_units */
+                hide_units_old = hide_units;
+                hide_units = g_settings_get_boolean(sensors_applet->settings, HIDE_UNITS);
+
+                /* scale value and set text using this value */
+                switch (sensor_type) {
+                    case TEMP_SENSOR:
+                        scale = (TemperatureScale) g_settings_get_int(sensors_applet->settings, TEMPERATURE_SCALE);
+                        /* scale value */
+                        sensor_value = sensors_applet_convert_temperature(sensor_value, CELSIUS, scale);
+
+                        sensor_value = (sensor_value * sensor_multiplier) + sensor_offset;
+                        switch (scale) {
+                            case FAHRENHEIT:
+                                value_text = g_strdup_printf("%2.0f %s", sensor_value, (hide_units ? "" : UNITS_FAHRENHEIT));
+                                /* tooltip should
+                                 * always display
+                                 * units */
+                                value_tooltip = g_strdup_printf("%2.0f %s", sensor_value, UNITS_FAHRENHEIT);
+                               
+                                break;
+                            case CELSIUS:
+                                value_text = g_strdup_printf("%2.0f %s", sensor_value, (hide_units ? "" : UNITS_CELSIUS));
+                                value_tooltip = g_strdup_printf("%2.0f %s", sensor_value, UNITS_CELSIUS);
+                                break;
+                            case KELVIN:
+                                value_text = g_strdup_printf("%2.0f", sensor_value);
+                                value_tooltip = g_strdup(value_text);
+                                break;
                         }
+                        break;
+
+                    case FAN_SENSOR:
+                        sensor_value = (sensor_value * sensor_multiplier) + sensor_offset;
+                        value_text = g_strdup_printf("%4.0f %s", sensor_value, (hide_units ? "" : UNITS_RPM));
+                        value_tooltip = g_strdup_printf("%4.0f %s", sensor_value, UNITS_RPM);
+                        break;
+
+                    case VOLTAGE_SENSOR:
+                        sensor_value = (sensor_value * sensor_multiplier) + sensor_offset;
+                        value_text = g_strdup_printf("%4.2f %s", sensor_value, (hide_units ? "" : UNITS_VOLTAGE));
+                        value_tooltip = g_strdup_printf("%4.2f %s", sensor_value, UNITS_VOLTAGE);
+                        break;
+
+                    case CURRENT_SENSOR:
+                        sensor_value = (sensor_value * sensor_multiplier) + sensor_offset;
+                        value_text = g_strdup_printf("%4.2f %s", sensor_value, (hide_units ? "" : UNITS_CURRENT));
+                        value_tooltip = g_strdup_printf("%4.2f %s", sensor_value, UNITS_CURRENT);
+                        break;
+
+                } /* end switch(sensor_type) */
+            } /* end else on error */
+
+            /* setup for tooltips */
+            if (sensors_applet->show_tooltip)
+                    tooltip = g_strdup_printf("%s %s", sensor_label, value_tooltip);
+            g_free(value_tooltip);
+
+            /* only do icons and labels / graphs if needed */
+            display_mode = g_settings_get_int (sensors_applet->settings, DISPLAY_MODE);
+           
+            /* most users wont have a font size set */
+            font_size = g_settings_get_int (sensors_applet->settings, FONT_SIZE);
+
+            /* do icon if needed */
+            if (display_mode == DISPLAY_ICON ||
+                display_mode == DISPLAY_ICON_WITH_VALUE) {
+
+                /* update icon if icon range has changed if no
+                 * update has been done before */
+                if ((sensor_value_range(sensor_value, sensor_low_value, sensor_high_value) != sensor_value_range(active_sensor->sensor_values[0], active_sensor->sensor_low_value, active_sensor->sensor_high_value)) ||
+                    !(active_sensor->updated)) {
+
+                    active_sensor_update_sensor_value(active_sensor, sensor_value);
+                    active_sensor->sensor_low_value = sensor_low_value;
+                    active_sensor->sensor_high_value = sensor_high_value;
+                    active_sensor_update_icon(active_sensor, icon_pixbuf, sensor_type);
+                }
 
-                        old_value_text = value_text;
-
-                        if (sensor_alarm_enabled) {
-                                if (sensor_value >= sensor_high_value || 
-                                    sensor_value <= sensor_low_value) {
-                                        /* make value text red and
-                                         * activate alarm */
-                                        if (display_mode == DISPLAY_LABEL_WITH_VALUE ||
-                                            display_mode == DISPLAY_ICON_WITH_VALUE ||
-                                            display_mode == DISPLAY_VALUE) {
-                                                value_text = g_markup_printf_escaped("<span foreground=\"#FF0000\">%s</span>", old_value_text);
-                                                
-                                                g_free(old_value_text);
-                                        }
-                                        /* could have both coditions at once */
-                                        if (sensor_value >= sensor_high_value) {
-                                                active_sensor_alarm_on(active_sensor, HIGH_ALARM);
-                                        }
-
-                                        if (sensor_value <= sensor_low_value) {
-                                                active_sensor_alarm_on(active_sensor, LOW_ALARM);
-                                        }
-                                        
-                                } else {
-                                        /* make sure alarms are off */
-                                        active_sensor_all_alarms_off(active_sensor);
-                                }				
-                        } else { /* else for if alarm enabled */
-                                /* make sure all alarms are off */
-                                active_sensor_all_alarms_off(active_sensor);
-                        }
-			
-                        /* do value label */
-                        if (display_mode == DISPLAY_LABEL_WITH_VALUE ||
-                            display_mode == DISPLAY_ICON_WITH_VALUE ||
-                            display_mode == DISPLAY_VALUE) {
-                                if (font_size) {
-                                        old_value_text = value_text;
-
-                                        value_text = g_strdup_printf("<span font_desc=\"%d\">%s</span>", font_size, old_value_text);
-                                        g_free(old_value_text);
-                                }
-                                /*Keep the label as large as previous size unless hide_units has changed */
-                                gtk_widget_get_preferred_size (GTK_WIDGET (active_sensor->value),
-                                                                                         &req, NULL);
-                                if (!(hide_units_old == hide_units)){
-                                    label_min_width = 0;
-                                }
-                                else{
-                                    label_min_width = req.width;
-                                }
-                                gtk_label_set_markup(GTK_LABEL(active_sensor->value),
-                                                     value_text);
-                                gtk_widget_get_preferred_size (GTK_WIDGET (active_sensor->value),
-                                                                                          &req, NULL);
-                                label_width = MAX(req.width, label_min_width);
-                                gtk_widget_set_size_request (GTK_WIDGET (active_sensor->value),
-                                                                       label_min_width, req.height);
-                                if (tooltip) {
-                                        gtk_widget_set_tooltip_text(active_sensor->value,
-                                                                    tooltip);
-                                }
-                        }
-                        /* finished with value text */
-                        g_free(value_text);
-
-                        /* do label label */
-                        if (display_mode == DISPLAY_LABEL_WITH_VALUE) {
-                                if (font_size) {
-                                        old_value_text = sensor_label;
-                                        sensor_label = g_strdup_printf("<span font_desc=\"%d\">%s</span>", font_size, old_value_text);
-                                        g_free(old_value_text);
-                                }
-                                gtk_label_set_markup(GTK_LABEL(active_sensor->label),
-                                                     sensor_label);
-                                if (tooltip) {
-                                        gtk_widget_set_tooltip_text(active_sensor->label,
-                                                                    tooltip);
-                                }
+                if (tooltip) {
+                    gtk_widget_set_tooltip_text(active_sensor->icon, tooltip);
+                }
+            }
 
-                        }
+            active_sensor_update_sensor_value(active_sensor, sensor_value);
+            active_sensor->sensor_low_value = sensor_low_value;
+            active_sensor->sensor_high_value = sensor_high_value;
+
+            /* do graph if needed */
+            if (display_mode == DISPLAY_GRAPH) {
+                /* update graph color in case has changed */
+                gdk_rgba_parse(&(active_sensor->graph_color), graph_color);
+
+                gtk_widget_queue_draw (active_sensor->graph);
+                if (tooltip) {
+                    gtk_widget_set_tooltip_text(active_sensor->graph, tooltip);
+                }
+            }
 
-                        g_free(tooltip);
-		} else {
-                        g_debug("no get_sensor_value function yet installed for interface %s.", sensor_interface);
-		}
-		g_free(sensor_path);
-		g_free(sensor_id);
-		g_free(sensor_label);
-        	g_free(sensor_interface);
-	        g_free(graph_color);
-		g_object_unref(icon_pixbuf);
-		
-	} else {
-		g_debug("Error getting iter when updating sensor...");
-		
-	}
-        active_sensor->updated = TRUE;
+            old_value_text = value_text;
+
+            if (sensor_alarm_enabled) {
+                if (sensor_value >= sensor_high_value || sensor_value <= sensor_low_value) {
+
+                    /* make value text red and
+                     * activate alarm */
+                    if (display_mode == DISPLAY_LABEL_WITH_VALUE ||
+                        display_mode == DISPLAY_ICON_WITH_VALUE ||
+                        display_mode == DISPLAY_VALUE) {
+
+                        value_text = g_markup_printf_escaped("<span foreground=\"#FF0000\">%s</span>", old_value_text);
+                        g_free(old_value_text);
+                    }
+
+                    /* could have both coditions at once */
+                    if (sensor_value >= sensor_high_value) {
+                        active_sensor_alarm_on(active_sensor, HIGH_ALARM);
+                    }
+
+                    if (sensor_value <= sensor_low_value) {
+                        active_sensor_alarm_on(active_sensor, LOW_ALARM);
+                    }
+
+                } else {
+                    /* make sure alarms are off */
+                    active_sensor_all_alarms_off(active_sensor);
+                }
+            } else {
+                /* else for if alarm enabled */
+                /* make sure all alarms are off */
+                active_sensor_all_alarms_off(active_sensor);
+            }
+
+            /* do value label */
+            if (display_mode == DISPLAY_LABEL_WITH_VALUE ||
+                display_mode == DISPLAY_ICON_WITH_VALUE ||
+                display_mode == DISPLAY_VALUE) {
+
+                if (font_size) {
+                    old_value_text = value_text;
+
+                    value_text = g_strdup_printf("<span font_desc=\"%d\">%s</span>", font_size, old_value_text);
+                    g_free(old_value_text);
+                }
+
+                /*Keep the label as large as previous size unless hide_units has changed */
+                gtk_widget_get_preferred_size (GTK_WIDGET (active_sensor->value), &req, NULL);
+                if (!(hide_units_old == hide_units)) {
+                    label_min_width = 0;
+                } else {
+                    label_min_width = req.width;
+                }
+
+                gtk_label_set_markup(GTK_LABEL(active_sensor->value), value_text);
+
+                gtk_widget_get_preferred_size (GTK_WIDGET (active_sensor->value), &req, NULL);
+                label_width = MAX(req.width, label_min_width);
+                gtk_widget_set_size_request (GTK_WIDGET (active_sensor->value), label_min_width, req.height);
+
+                if (tooltip) {
+                    gtk_widget_set_tooltip_text(active_sensor->value, tooltip);
+                }
+            }
+            /* finished with value text */
+            g_free(value_text);
+
+            /* do label label */
+            if (display_mode == DISPLAY_LABEL_WITH_VALUE) {
+                if (font_size) {
+                    old_value_text = sensor_label;
+                    sensor_label = g_strdup_printf("<span font_desc=\"%d\">%s</span>", font_size, old_value_text);
+                    g_free(old_value_text);
+                }
+
+                gtk_label_set_markup(GTK_LABEL(active_sensor->label), sensor_label);
+                if (tooltip) {
+                        gtk_widget_set_tooltip_text(active_sensor->label, tooltip);
+                }
+            }
+
+            g_free(tooltip);
+        } else {
+            g_debug("no get_sensor_value function yet installed for interface %s.", sensor_interface);
+        }
+
+        g_free(sensor_path);
+        g_free(sensor_id);
+        g_free(sensor_label);
+        g_free(sensor_interface);
+        g_free(graph_color);
+        g_object_unref(icon_pixbuf);
+
+    } else {
+        g_debug("Error getting iter when updating sensor...");
+    }
+
+    active_sensor->updated = TRUE;
 
 }
 
 /* to be called when the icon within the GtkRowReference that this
  * sensor references is changed - updates icon based upon value in the
  * ActiveSensor */
-void active_sensor_icon_changed(ActiveSensor *active_sensor,
-				SensorsApplet *sensors_applet) {
-	
-	GtkTreeModel *model;
-	GtkTreePath *path;
-	GtkTreeIter iter;
-	
-	SensorType sensor_type;
-        GdkPixbuf *icon_pixbuf;
-
-	g_assert(active_sensor);
-	g_assert(sensors_applet);
-
-	model = gtk_tree_row_reference_get_model(active_sensor->sensor_row);
-	path = gtk_tree_row_reference_get_path(active_sensor->sensor_row);
-
-	/* if can successfully get iter can proceed */
-	if (gtk_tree_model_get_iter(model, &iter, path)) {
-		gtk_tree_model_get(GTK_TREE_MODEL(sensors_applet->sensors),
-				   &iter,
-				   SENSOR_TYPE_COLUMN, &sensor_type,
-				   ICON_PIXBUF_COLUMN, &icon_pixbuf,
-				   -1);
-
-		active_sensor_update_icon(active_sensor,
-                                          icon_pixbuf,
-                                          sensor_type);
-		g_object_unref(icon_pixbuf);
-	}
-	gtk_tree_path_free(path);
+void active_sensor_icon_changed(ActiveSensor *active_sensor, SensorsApplet *sensors_applet) {
+
+    GtkTreeModel *model;
+    GtkTreePath *path;
+    GtkTreeIter iter;
+
+    SensorType sensor_type;
+    GdkPixbuf *icon_pixbuf;
+
+    g_assert(active_sensor);
+    g_assert(sensors_applet);
+
+    model = gtk_tree_row_reference_get_model(active_sensor->sensor_row);
+    path = gtk_tree_row_reference_get_path(active_sensor->sensor_row);
+
+    /* if can successfully get iter can proceed */
+    if (gtk_tree_model_get_iter(model, &iter, path)) {
+        gtk_tree_model_get(GTK_TREE_MODEL(sensors_applet->sensors),
+                                           &iter,
+                                           SENSOR_TYPE_COLUMN, &sensor_type,
+                                           ICON_PIXBUF_COLUMN, &icon_pixbuf,
+                                           -1);
+
+        active_sensor_update_icon(active_sensor, icon_pixbuf, sensor_type);
+        g_object_unref(icon_pixbuf);
+    }
+    gtk_tree_path_free(path);
 }
diff --git a/sensors-applet/active-sensor.h b/sensors-applet/active-sensor.h
index 375fa75..6db381e 100644
--- a/sensors-applet/active-sensor.h
+++ b/sensors-applet/active-sensor.h
@@ -27,47 +27,46 @@
 #include "sensors-applet.h"
 
 struct _ActiveSensor {
-        SensorsApplet *sensors_applet;
+    SensorsApplet *sensors_applet;
 
-	/* widgets to render to display the sensor */
-	GtkWidget *label;
-	GtkWidget *icon;
-	GtkWidget *value;
-        GtkWidget *graph;
-        GtkWidget *graph_frame;
+    /* widgets to render to display the sensor */
+    GtkWidget *label;
+    GtkWidget *icon;
+    GtkWidget *value;
+    GtkWidget *graph;
+    GtkWidget *graph_frame;
 
-        GdkRGBA graph_color;
+    GdkRGBA graph_color;
 
-	GtkTreeRowReference *sensor_row;
+    GtkTreeRowReference *sensor_row;
 
 #ifdef HAVE_LIBNOTIFY
-        NotifyNotification *notification[NUM_NOTIFS];
+    NotifyNotification *notification[NUM_NOTIFS];
 #endif
 
-        gboolean updated;
+    gboolean updated;
 
-	/* alarm related stuff */
-	gint alarm_timeout_id[NUM_ALARMS];
-	gchar *alarm_command[NUM_ALARMS];
-        gint alarm_timeout;
+    /* alarm related stuff */
+    gint alarm_timeout_id[NUM_ALARMS];
+    gchar *alarm_command[NUM_ALARMS];
+    gint alarm_timeout;
 
-	/* buffer of sensor values */
-        gdouble *sensor_values;
+    /* buffer of sensor values */
+    gdouble *sensor_values;
 
-        /* length of sensor_values buffer */
-        gint num_samples;
-        
-	gdouble sensor_low_value;
-	gdouble sensor_high_value;	
+    /* length of sensor_values buffer */
+    gint num_samples;
+
+    gdouble sensor_low_value;
+    gdouble sensor_high_value;
 };
 
-ActiveSensor *active_sensor_new(SensorsApplet *sensors_applet,
-                                GtkTreeRowReference *sensor_row);
+ActiveSensor *active_sensor_new(SensorsApplet *sensors_applet, GtkTreeRowReference *sensor_row);
 void active_sensor_destroy(ActiveSensor *active_sensor);
 gint active_sensor_compare(ActiveSensor *a, ActiveSensor *b);
 void active_sensor_update(ActiveSensor *sensor, SensorsApplet *sensors_applet);
 void active_sensor_icon_changed(ActiveSensor *sensor, SensorsApplet *sensors_applet);
-void active_sensor_update_graph_dimensions(ActiveSensor *as,
-                                           gint dimensions[2]);
+void active_sensor_update_graph_dimensions(ActiveSensor *as, gint dimensions[2]);
 void active_sensor_alarm_off(ActiveSensor *active_sensor, NotifType notif_type);
+
 #endif /* ACTIVE_SENSOR_H */
diff --git a/sensors-applet/main.c b/sensors-applet/main.c
index dc3a2ed..4b820ca 100644
--- a/sensors-applet/main.c
+++ b/sensors-applet/main.c
@@ -27,19 +27,21 @@
 static gboolean sensors_applet_fill(MatePanelApplet *applet,
                                     const gchar *iid,
                                     gpointer data) {
-	SensorsApplet *sensors_applet;
-	gboolean retval = FALSE;
-        if (strcmp(iid, "SensorsApplet") == 0) {
-		sensors_applet = g_new0(SensorsApplet, 1);
-		sensors_applet->applet = applet;
-		sensors_applet_init(sensors_applet);
-		retval = TRUE;
-	}
-	return retval;
+
+    SensorsApplet *sensors_applet;
+    gboolean retval = FALSE;
+
+    if (strcmp(iid, "SensorsApplet") == 0) {
+        sensors_applet = g_new0(SensorsApplet, 1);
+        sensors_applet->applet = applet;
+        sensors_applet_init(sensors_applet);
+        retval = TRUE;
+    }
+    return retval;
 }
 
 MATE_PANEL_APPLET_OUT_PROCESS_FACTORY ("SensorsAppletFactory",
-									   PANEL_TYPE_APPLET,
-									   "SensorsApplet",
-									   sensors_applet_fill,
-									   NULL);
+                                       PANEL_TYPE_APPLET,
+                                       "SensorsApplet",
+                                       sensors_applet_fill,
+                                       NULL);