+INCLUDES = -DMATELOCALEDIR=\""$(datadir)/locale/"\" \

+ $(GLIB_CFLAGS) $(GTK_CFLAGS) $(MATE_CFLAGS) $(CAIRO_CFLAGS) $(LIBMATENOTIFY_CFLAGS)

+LIBS = $(GLIB_LIBS) $(GTK_LIBS) $(MATE_LIBS) $(CAIRO_LIBS) $(LIBMATENOTIFY_LIBS)

+if LIBMATENOTIFY

+libmatenotify_SRC = active-sensor-libmatenotify.c \

+ active-sensor-libmatenotify.h

+libmatenotify_SRC =

+ sensors-applet-mateconf.c \

+ sensors-applet-mateconf.h \

+ $(libmatenotify_SRC)

+ sensors-applet-mateconf.c sensors-applet-mateconf.h \

+ active-sensor-libmatenotify.c active-sensor-libmatenotify.h

+@LIBMATENOTIFY_TRUE@am__objects_1 = active-sensor-libmatenotify.$(OBJEXT)

+ sensors-applet-mateconf.$(OBJEXT) $(am__objects_1)

+MATE_CFLAGS = @MATE_CFLAGS@

+MATE_LIBS = @MATE_LIBS@

+LIBMATENOTIFY_CFLAGS = @LIBMATENOTIFY_CFLAGS@

+LIBMATENOTIFY_LIBS = @LIBMATENOTIFY_LIBS@

+LIBS = $(GLIB_LIBS) $(GTK_LIBS) $(MATE_LIBS) $(CAIRO_LIBS) $(LIBMATENOTIFY_LIBS)

+INCLUDES = -DMATELOCALEDIR=\""$(datadir)/locale/"\" \

+ $(GLIB_CFLAGS) $(GTK_CFLAGS) $(MATE_CFLAGS) $(CAIRO_CFLAGS) $(LIBMATENOTIFY_CFLAGS)

+@LIBMATENOTIFY_FALSE@libmatenotify_SRC =

+@LIBMATENOTIFY_TRUE@libmatenotify_SRC = active-sensor-libmatenotify.c \

+@LIBMATENOTIFY_TRUE@ active-sensor-libmatenotify.h

+ sensors-applet-mateconf.c \

+ sensors-applet-mateconf.h \

+ $(libmatenotify_SRC)

+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/active-sensor-libmatenotify.Po@am__quote@

+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sensors-applet-mateconf.Po@am__quote@

+#include <mate.h>

+/*

+ * Copyright (C) 2005-2009 Alex Murray <[email protected]>

+ *

+ * This program is free software; you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2 of the License, or

+ * (at your option) any later version.

+ *

+ * This program is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+ * GNU General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

+ */

+

+#ifdef HAVE_CONFIG_H

+#include "config.h"

+#endif /* HAVE_CONFIG_H */

+

+#ifdef HAVE_LIBMATENOTIFY

+#include <libmatenotify/notify.h>

+#endif

+

+#include "active-sensor-libmatenotify.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;

+ }

+ }

+}

+

+

+void active_sensor_libmatenotify_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;

+ }

+}

+

+void active_sensor_libmatenotify_notify(ActiveSensor *active_sensor,

+ NotifType notif_type,

+ const gchar *summary,

+ const gchar *message,

+ const gchar *icon_filename,

+ gint timeout_msecs,

+ GtkWidget *attach) {

+ 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);

+

+ /* leave any existing notification since most likely hasn't changed */

+ if (active_sensor->notification[notif_type] != NULL) {

+ return;

+/* active_sensor_libmatenotify_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,

+ attach);

+ 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);

+ }

+

+

+

+}

+

+/*

+ * Copyright (C) 2005-2009 Alex Murray <[email protected]>

+ *

+ * This program is free software; you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2 of the License, or

+ * (at your option) any later version.

+ *

+ * This program is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+ * GNU General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

+ */

+

+#ifndef ACTIVE_SESNOR_LIBMATENOTIFY_H

+#define ACTIVE_SENSOR_LIBMATENOTIFY_H

+

+#include "sensors-applet.h"

+#include "active-sensor.h"

+

+void active_sensor_libmatenotify_notify(ActiveSensor *active_sensor,

+ NotifType notif_type,

+ const gchar *summary,

+ const gchar *message,

+ const gchar *icon_filename,

+ gint timeout_msecs,

+ GtkWidget *attach);

+void active_sensor_libmatenotify_notify_end(ActiveSensor *active_sensor,

+ NotifType notif_type);

+

+#endif /* SENSORS_APPLET_LIBMATENOTIFY_H */

+#include <mateconf/mateconf-client.h>

+#include <mate.h>

+#include "sensors-applet-mateconf.h"

+ pid = mate_execute_shell(NULL,

+ MatePanelAppletOrient orient;

+ orient = mate_panel_applet_get_orient(active_sensor->sensors_applet->applet);

+ graph_size = mate_panel_applet_mateconf_get_int(active_sensor->sensors_applet->applet,

+ horizontal = ((orient == MATE_PANEL_APPLET_ORIENT_UP) ||

+ (orient == MATE_PANEL_APPLET_ORIENT_DOWN));

+ /* hidden mateconf options */

+ MateConfClient *client;

+ /* use hidden mateconf key for hide_units */

+ if ((client = mateconf_client_get_default()) != NULL) {

+ hide_units = mateconf_client_get_bool(client,

+ g_debug("Could not get hide units from MateConf - assuming false");

+ scale = (TemperatureScale)mate_panel_applet_mateconf_get_int(sensors_applet->applet, TEMPERATURE_SCALE, NULL);

+ display_mode = mate_panel_applet_mateconf_get_int(sensors_applet->applet,

+ if ((client = mateconf_client_get_default()) != NULL) {

+ font_size = mateconf_client_get_int(client,

+ g_debug("Could not get font size from MateConf - assuming default size");

+#ifdef HAVE_LIBMATENOTIFY

+#include <libmatenotify/notify.h>

+#include "active-sensor-libmatenotify.h"

+#ifdef HAVE_LIBMATENOTIFY

+/* libmatenotify available */

+#undef HAVE_LIBMATENOTIFY

+#include <mate-panel-applet.h>

+static gboolean sensors_applet_fill(MatePanelApplet *applet,

+MATE_PANEL_APPLET_MATECOMPONENT_FACTORY ("OAFIID:SensorsApplet_Factory",

+#include <libmate/libmate.h>

+#include "sensors-applet-mateconf.h"

+ setup, so store all values in mateconf */

+ if (sensors_applet_mateconf_save_sensors(sensors_applet))

+ mate_panel_applet_mateconf_set_bool(sensors_applet->applet,

+ sensors_applet->timeout_id = g_timeout_add_seconds(mate_panel_applet_mateconf_get_int(sensors_applet->applet, TIMEOUT, NULL) / 1000, (GSourceFunc)sensors_applet_update_active_sensors, sensors_applet);

+ mate_panel_applet_mateconf_set_int(prefs_dialog->sensors_applet->applet, TIMEOUT, value, NULL);

+ mate_panel_applet_mateconf_set_int(prefs_dialog->sensors_applet->applet,

+ mate_panel_applet_mateconf_set_int(prefs_dialog->sensors_applet->applet,

+ scales[OLD_TEMP_SCALE] = (TemperatureScale)mate_panel_applet_mateconf_get_int(prefs_dialog->sensors_applet->applet,

+ mate_panel_applet_mateconf_set_int(prefs_dialog->sensors_applet->applet,

+#ifdef HAVE_LIBMATENOTIFY

+ mate_panel_applet_mateconf_set_bool(prefs_dialog->sensors_applet->applet,

+ mate_panel_applet_mateconf_set_int(prefs_dialog->sensors_applet->applet, GRAPH_SIZE, value, NULL);

+ display_mode = mate_panel_applet_mateconf_get_int(sensors_applet->applet, DISPLAY_MODE, NULL);

+ gtk_combo_box_set_active(prefs_dialog->layout_mode_combo_box, mate_panel_applet_mateconf_get_int(sensors_applet->applet, LAYOUT_MODE, NULL));

+ gtk_combo_box_set_active(prefs_dialog->temperature_scale_combo_box, mate_panel_applet_mateconf_get_int(sensors_applet->applet, TEMPERATURE_SCALE, NULL));

+ "value", (gdouble)mate_panel_applet_mateconf_get_int(sensors_applet->applet,

+ "value", (gdouble)mate_panel_applet_mateconf_get_int(sensors_applet->applet,

+ "value", (gdouble) mate_panel_applet_mateconf_get_int(sensors_applet->applet, TIMEOUT, NULL) / 1000.0,

+#ifdef HAVE_LIBMATENOTIFY

+ mate_panel_applet_mateconf_get_bool(sensors_applet->applet,

+#ifdef HAVE_LIBMATENOTIFY

+#ifdef HAVE_LIBMATENOTIFY

+#ifdef HAVE_LIBMATENOTIFY

+#include <mate.h>

+/*

+ * Copyright (C) 2005-2009 Alex Murray <[email protected]>

+ *

+ * This program is free software; you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2 of the License, or

+ * (at your option) any later version.

+ *

+ * This program is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+ * GNU General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

+ */

+

+#ifdef HAVE_CONFIG_H

+#include "config.h"

+#endif /* HAVE_CONFIG_H */

+

+#include "sensors-applet.h"

+#include "sensors-applet-mateconf.h"

+

+#define DEFAULT_TIMEOUT 2000

+#define DEFAULT_GRAPH_SIZE 42

+

+static const gchar * const compatible_versions[] = {

+ PACKAGE_VERSION, /* always list current version */

+ "2.2.6",

+ "2.2.5",

+ "2.2.4",

+ "2.2.3",

+ "2.2.2",

+};

+

+#define NUM_COMPATIBLE_VERSIONS G_N_ELEMENTS(compatible_versions)

+

+typedef enum {

+ SENSORS_APPLET_MATECONF_ERROR = 0,

+ SENSORS_APPLET_VERSION_ERROR,

+} SensorsAppletMateConfError;

+

+static const gchar * const error_titles[] = {

+ N_("An error occurred loading the stored sensors data"),

+ N_("Incompatible sensors configuration found")

+};

+

+static const gchar * const error_messages[] = {

+ N_("An error has occurred when loading the stored sensors data. "

+ "The default values will be used to recover from this error."),

+

+ N_("Unfortunately the previous configuration for MATE Sensors Applet "

+ "is not compatible with this version. The existing sensors data "

+ "will be overwritten with the default values for this new version.")

+};

+

+/* function to be called if an error occurs

+ when loading values from mateconf */

+static void sensors_applet_mateconf_error_occurred(SensorsAppletMateConfError error) {

+ GtkWidget *dialog;

+ gchar *markup;

+

+ g_debug("Error occurred: %s", error_titles[error]);

+ markup = g_markup_printf_escaped("<span size=\"large\" weight=\"bold\">%s</span>\n\n%s", _(error_titles[error]), _(error_messages[error]));

+

+ dialog = gtk_message_dialog_new_with_markup(NULL, /* no parent window */

+ GTK_DIALOG_MODAL,

+ GTK_MESSAGE_WARNING,

+ GTK_BUTTONS_OK,

+ "%s", markup);

+

+ g_free(markup);

+

+ /* runs dialog as modal and doesn't return until user clicks

+ * button */

+ gtk_dialog_run(GTK_DIALOG(dialog));

+ gtk_widget_destroy(GTK_WIDGET(dialog));

+}

+

+

+static void sensors_applet_mateconf_set_defaults(SensorsApplet *sensors_applet) {

+ mate_panel_applet_mateconf_set_int(sensors_applet->applet, DISPLAY_MODE, DISPLAY_ICON_WITH_VALUE, NULL);

+ mate_panel_applet_mateconf_set_int(sensors_applet->applet, LAYOUT_MODE, VALUE_BESIDE_LABEL, NULL);

+ mate_panel_applet_mateconf_set_int(sensors_applet->applet, TEMPERATURE_SCALE, CELSIUS, NULL);

+ mate_panel_applet_mateconf_set_int(sensors_applet->applet, TIMEOUT, DEFAULT_TIMEOUT, NULL);

+ mate_panel_applet_mateconf_set_int(sensors_applet->applet, GRAPH_SIZE, DEFAULT_GRAPH_SIZE, NULL);

+#ifdef HAVE_LIBMATENOTIFY

+ mate_panel_applet_mateconf_set_bool(sensors_applet->applet, DISPLAY_NOTIFICATIONS, TRUE, NULL);

+#endif

+ mate_panel_applet_mateconf_set_bool(sensors_applet->applet, IS_SETUP, FALSE, NULL);

+

+}

+

+/**

+ * Returns TRUE is old_version is one of the compatible versions

+ */

+static gboolean sensors_applet_mateconf_is_compatible(const gchar *old_version) {

+ guint i;

+ for (i = 0; i < NUM_COMPATIBLE_VERSIONS; i++) {

+ if (g_ascii_strcasecmp(old_version, compatible_versions[i]) == 0) {

+ return TRUE;

+ }

+ }

+ return FALSE;

+}

+

+

+void sensors_applet_mateconf_setup(SensorsApplet *sensors_applet) {

+ gboolean setup = FALSE;

+ gchar *old_version;

+ GError *error = NULL;

+

+ /* need to convert old num_samples value to new GRAPH_SIZE

+ * parameter */

+ gint num_samples;

+ if ((num_samples = mate_panel_applet_mateconf_get_int(sensors_applet->applet,

+ "num_samples",

+ NULL))) {

+ g_debug("Convering old num_samples value %d into graph_size", num_samples);

+ mate_panel_applet_mateconf_set_int(sensors_applet->applet,

+ GRAPH_SIZE,

+ (num_samples + GRAPH_FRAME_EXTRA_WIDTH),

+ NULL);

+ /* reset num_samples to zero */

+ mate_panel_applet_mateconf_set_int(sensors_applet->applet,

+ "num_samples",

+ 0,

+ NULL);

+

+ }

+

+ /* convert old alarm_commands to high and low if exist */

+ GSList *alarm_commands;

+ if ((alarm_commands = mate_panel_applet_mateconf_get_list(sensors_applet->applet,

+ "alarm_commands",

+ MATECONF_VALUE_STRING,

+ NULL))) {

+

+ g_debug("Converting old alarm commands to new high and low commands");

+

+ mate_panel_applet_mateconf_set_list(sensors_applet->applet,

+ LOW_ALARM_COMMANDS,

+ MATECONF_VALUE_STRING,

+ alarm_commands,

+ NULL);

+ mate_panel_applet_mateconf_set_list(sensors_applet->applet,

+ HIGH_ALARM_COMMANDS,

+ MATECONF_VALUE_STRING,

+ alarm_commands,

+ NULL);

+ /* reset old list to null */

+ mate_panel_applet_mateconf_set_list(sensors_applet->applet,

+ "alarm_commands",

+ MATECONF_VALUE_STRING,

+ NULL,

+ NULL);

+ g_slist_foreach(alarm_commands, (GFunc)g_free, NULL);

+ g_slist_free(alarm_commands);

+

+ }

+

+ setup = mate_panel_applet_mateconf_get_bool(sensors_applet->applet,

+ IS_SETUP, &error);

+ if (error) {

+ g_debug("Previous configuration not found: %s, setting up manually", error->message);

+ g_error_free(error);

+ error = NULL;

+ setup = FALSE;

+ }

+

+

+ if (setup) {

+ /* see if setup version matches */

+ old_version = mate_panel_applet_mateconf_get_string(sensors_applet->applet,

+ SENSORS_APPLET_VERSION,

+ &error);

+ /* if versions don't match or there is no saved

+ * version string then need to overwrite old config */

+ if (error) {

+ g_debug("Error getting old version string: %s", error->message);

+ g_error_free(error);

+ error = NULL;

+ old_version = NULL;

+ }

+

+ if (old_version) {

+ if (sensors_applet_mateconf_is_compatible(old_version)) {

+ /* previously setup and versions match so use

+ * old values */

+ g_debug("MateConf data is compatible. Trying to set up sensors from mateconf data");

+ if (sensors_applet_mateconf_setup_sensors(sensors_applet)) {

+ g_debug("done setting up from mateconf");

+ } else {

+ g_debug("Setting mateconf defaults only");

+ sensors_applet_mateconf_set_defaults(sensors_applet);

+ }

+ g_free(old_version);

+

+ return;

+

+

+ }

+ g_free(old_version);

+

+ }

+ sensors_applet_notify(sensors_applet, MATECONF_READ_ERROR);

+

+

+ sensors_applet_mateconf_error_occurred(SENSORS_APPLET_VERSION_ERROR);

+ }

+

+ /* use defaults */

+ g_debug("Setting mateconf defaults only");

+ sensors_applet_mateconf_set_defaults(sensors_applet);

+}

+

+enum {

+ PATHS_INDEX = 0,

+ IDS_INDEX,

+ LABELS_INDEX,

+ INTERFACES_INDEX,

+ SENSOR_TYPES_INDEX,

+ ENABLES_INDEX,

+ LOW_VALUES_INDEX,

+ HIGH_VALUES_INDEX,

+ ALARM_ENABLES_INDEX,

+ LOW_ALARM_COMMANDS_INDEX,

+ HIGH_ALARM_COMMANDS_INDEX,

+ ALARM_TIMEOUTS_INDEX,

+ MULTIPLIERS_INDEX,

+ OFFSETS_INDEX,

+ ICON_TYPES_INDEX,

+ GRAPH_COLORS_INDEX,

+ NUM_KEYS

+};

+

+const gchar * const keys[NUM_KEYS] = {

+ PATHS,

+ IDS,

+ LABELS,

+ INTERFACES,

+ SENSOR_TYPES,

+ ENABLES,

+ LOW_VALUES,

+ HIGH_VALUES,

+ ALARM_ENABLES,

+ LOW_ALARM_COMMANDS,

+ HIGH_ALARM_COMMANDS,

+ ALARM_TIMEOUTS,

+ MULTIPLIERS,

+ OFFSETS,

+ ICON_TYPES,

+ GRAPH_COLORS,

+};

+

+/* MUST CORRESPOND TO ABOVE KEYS */

+const MateConfValueType key_types[NUM_KEYS] = {

+ MATECONF_VALUE_STRING, /* PATHS */

+ MATECONF_VALUE_STRING, /* IDS, */

+ MATECONF_VALUE_STRING, /* LABELS */

+ MATECONF_VALUE_STRING, /* INTERFACES, */

+ MATECONF_VALUE_INT, /* SENSOR_TYPES, */

+ MATECONF_VALUE_BOOL, /* ENABLES, */

+ MATECONF_VALUE_INT, /* LOW_VALUES, */

+ MATECONF_VALUE_INT, /* HIGH_VALUES, */

+ MATECONF_VALUE_BOOL, /* ALARM_ENABLES, */

+ MATECONF_VALUE_STRING, /* LOW_ALARM_COMMANDS, */

+ MATECONF_VALUE_STRING, /* HIGH_ALARM_COMMANDS, */

+ MATECONF_VALUE_INT, /* ALARM_TIMEOUTS, */

+ MATECONF_VALUE_INT, /* MULTIPLIERS, */

+ MATECONF_VALUE_INT, /* OFFSETS, */

+ MATECONF_VALUE_INT, /* ICON_TYPES, */

+ MATECONF_VALUE_STRING /* GRAPH_COLORS, */

+};

+

+void sensors_applet_mateconf_set_current_to_lists(GSList *current[],

+ GSList *lists[],

+ int len) {

+ for (len--; len >= 0; len--) {

+ current[len] = lists[len];

+ }

+}

+

+int sensors_applet_mateconf_current_not_null(GSList *current[],

+ int len) {

+ for (len--; len >= 0; len--) {

+ if (NULL == current[len]) {

+ return FALSE;

+ }

+ }

+ return TRUE;

+}

+void sensors_applet_mateconf_current_get_next(GSList *current[],

+ int len) {

+ for (len--; len >= 0; len--) {

+ current[len] = g_slist_next(current[len]);

+ }

+}

+

+void sensors_applet_mateconf_free_lists(GSList *lists[],

+ int len) {

+ for (len--; len >= 0; len--) {

+ if (key_types[len] == MATECONF_VALUE_STRING) {

+ g_slist_foreach(lists[len], (GFunc)g_free, NULL);

+ }

+ g_slist_free(lists[len]);

+ }

+

+}

+

+/* gets called if are already setup so we don't have to manually go

+ through and find sensors etc again */

+gboolean sensors_applet_mateconf_setup_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 */

+ int i;

+ GSList *lists[NUM_KEYS] = {NULL};

+

+ GSList *current[NUM_KEYS] = {NULL};

+

+ GError *error = NULL;

+

+ for (i = 0; i < NUM_KEYS; i++) {

+ lists[i] = mate_panel_applet_mateconf_get_list(sensors_applet->applet,

+ keys[i],

+ key_types[i],

+ &error);

+ if (error || NULL == lists[i]) {

+ sensors_applet_notify(sensors_applet, MATECONF_READ_ERROR);

+

+ sensors_applet_mateconf_error_occurred(SENSORS_APPLET_MATECONF_ERROR);

+ if (error) {

+ g_error_free(error);

+ }

+ return FALSE;

+ }

+ }

+

+ for (sensors_applet_mateconf_set_current_to_lists(current,

+ lists,

+ NUM_KEYS);

+ sensors_applet_mateconf_current_not_null(current,

+ NUM_KEYS);

+ sensors_applet_mateconf_current_get_next(current,

+ NUM_KEYS)) {

+

+

+ g_debug("trying to add sensor from mateconf data: %s\n", (gchar *)(current[IDS_INDEX]->data));

+ /* need to ensure correct order */

+ sensors_applet_add_sensor(sensors_applet,

+ (gchar *)(current[PATHS_INDEX]->data),

+ (gchar *)(current[IDS_INDEX]->data),

+ (gchar *)(current[LABELS_INDEX]->data),

+ (gchar *)(current[INTERFACES_INDEX]->data),

+ GPOINTER_TO_UINT(current[SENSOR_TYPES_INDEX]->data),

+ GPOINTER_TO_INT(current[ENABLES_INDEX]->data),

+ (gdouble)(GPOINTER_TO_INT(current[LOW_VALUES_INDEX]->data) / 1000.0),

+ (gdouble)(GPOINTER_TO_INT(current[HIGH_VALUES_INDEX]->data) / 1000.0),

+ GPOINTER_TO_INT(current[ALARM_ENABLES_INDEX]->data),

+ (gchar *)(current[LOW_ALARM_COMMANDS_INDEX]->data),

+ (gchar *)(current[HIGH_ALARM_COMMANDS_INDEX]->data),

+ GPOINTER_TO_INT(current[ALARM_TIMEOUTS_INDEX]->data),

+ (gdouble)(GPOINTER_TO_INT(current[MULTIPLIERS_INDEX]->data) / 1000.0),

+ (gdouble)(GPOINTER_TO_INT(current[OFFSETS_INDEX]->data) / 1000.0),

+ (SensorType)GPOINTER_TO_UINT(current[ICON_TYPES_INDEX]->data),

+ (gchar *)(current[GRAPH_COLORS_INDEX]->data)

+

+ );

+

+ }

+ sensors_applet_mateconf_free_lists(lists,

+ NUM_KEYS);

+

+ return TRUE;

+}

+

+

+gboolean sensors_applet_mateconf_save_sensors(SensorsApplet *sensors_applet) {

+ /* write everything to mateconf 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;

+

+ /* make sure all are initialized to null - since list of

+ * intializers is horter than number of element, rest get set

+ * to 0 (ie NULL) */

+ GSList *lists[NUM_KEYS] = {NULL};

+ int i;

+ gchar *current_path, *current_id, *current_label, *current_interface,

+ *current_low_alarm_command, *current_high_alarm_command,

+ *current_graph_color;

+ gboolean current_enable, current_alarm_enable;

+ gdouble current_low_value, current_high_value, current_multiplier,

+ current_offset;

+ guint current_alarm_timeout, current_sensor_type,

+ current_icon_type;

+

+ GError *error = NULL;

+

+ /* 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); not_end_of_interfaces; not_end_of_interfaces = gtk_tree_model_iter_next(GTK_TREE_MODEL(sensors_applet->sensors), &interfaces_iter)) {

+ // store a mateconf key for this interface

+ gtk_tree_model_get(GTK_TREE_MODEL(sensors_applet->sensors),

+ &interfaces_iter,

+ ID_COLUMN, &current_id,

+ -1);

+

+ mate_panel_applet_mateconf_set_bool(sensors_applet->applet, current_id, TRUE, NULL);

+ 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); not_end_of_sensors; not_end_of_sensors = gtk_tree_model_iter_next(GTK_TREE_MODEL(sensors_applet->sensors), &sensors_iter)) {

+ gtk_tree_model_get(GTK_TREE_MODEL(sensors_applet->sensors),

+ &sensors_iter,

+ PATH_COLUMN, &current_path,

+ ID_COLUMN, &current_id,

+ LABEL_COLUMN, &current_label,

+ INTERFACE_COLUMN, &current_interface,

+ SENSOR_TYPE_COLUMN, &current_sensor_type,

+ ENABLE_COLUMN, &current_enable,

+ LOW_VALUE_COLUMN, &current_low_value,

+ HIGH_VALUE_COLUMN, &current_high_value,

+ ALARM_ENABLE_COLUMN, &current_alarm_enable,

+ LOW_ALARM_COMMAND_COLUMN, &current_low_alarm_command,

+ HIGH_ALARM_COMMAND_COLUMN, &current_high_alarm_command,

+ ALARM_TIMEOUT_COLUMN, &current_alarm_timeout,

+ MULTIPLIER_COLUMN, &current_multiplier,

+ OFFSET_COLUMN, &current_offset,

+ ICON_TYPE_COLUMN, &current_icon_type,

+ GRAPH_COLOR_COLUMN, &current_graph_color,

+ -1);

+

+ /* prepend values as this is faster then just

+ reverse list when finished */

+ lists[PATHS_INDEX] = g_slist_prepend(lists[PATHS_INDEX], current_path);

+ lists[IDS_INDEX] = g_slist_prepend(lists[IDS_INDEX], current_id);

+ lists[LABELS_INDEX] = g_slist_prepend(lists[LABELS_INDEX], current_label);

+ lists[INTERFACES_INDEX] = g_slist_prepend(lists[INTERFACES_INDEX], current_interface);

+ lists[ENABLES_INDEX] = g_slist_prepend(lists[ENABLES_INDEX], GINT_TO_POINTER(current_enable));

+ lists[LOW_VALUES_INDEX] = g_slist_prepend(lists[LOW_VALUES_INDEX], GINT_TO_POINTER((gint)(current_low_value * 1000)));

+ lists[HIGH_VALUES_INDEX] = g_slist_prepend(lists[HIGH_VALUES_INDEX], GINT_TO_POINTER((gint)(current_high_value * 1000)));

+ lists[ALARM_ENABLES_INDEX] = g_slist_prepend(lists[ALARM_ENABLES_INDEX], GINT_TO_POINTER(current_alarm_enable));

+ lists[LOW_ALARM_COMMANDS_INDEX] = g_slist_prepend(lists[LOW_ALARM_COMMANDS_INDEX], current_low_alarm_command);

+ lists[HIGH_ALARM_COMMANDS_INDEX] = g_slist_prepend(lists[HIGH_ALARM_COMMANDS_INDEX], current_high_alarm_command);

+ lists[ALARM_TIMEOUTS_INDEX] = g_slist_prepend(lists[ALARM_TIMEOUTS_INDEX], GINT_TO_POINTER(current_alarm_timeout));

+ lists[SENSOR_TYPES_INDEX] = g_slist_prepend(lists[SENSOR_TYPES_INDEX], GUINT_TO_POINTER(current_sensor_type));

+ lists[MULTIPLIERS_INDEX] = g_slist_prepend(lists[MULTIPLIERS_INDEX], GINT_TO_POINTER((gint)(current_multiplier * 1000)));

+ lists[OFFSETS_INDEX] = g_slist_prepend(lists[OFFSETS_INDEX], GINT_TO_POINTER((gint)(current_offset * 1000)));

+ lists[ICON_TYPES_INDEX] = g_slist_prepend(lists[ICON_TYPES_INDEX], GUINT_TO_POINTER(current_icon_type));

+ lists[GRAPH_COLORS_INDEX] = g_slist_prepend(lists[GRAPH_COLORS_INDEX], current_graph_color);

+ }

+ }

+

+ /* keep lists in original order */

+ for (i = 0; i < NUM_KEYS; i++) {

+ if (lists[i] != NULL) {

+ lists[i] = g_slist_reverse(lists[i]);

+

+ mate_panel_applet_mateconf_set_list(sensors_applet->applet,

+ keys[i],

+ key_types[i],

+ lists[i], &error);

+ if (error) {

+ sensors_applet_notify(sensors_applet, MATECONF_WRITE_ERROR);

+

+ g_error_free(error);

+ return FALSE;

+ }

+ } else {

+ g_debug("list %s is NULL", keys[i]);

+ }

+

+ }

+

+ sensors_applet_mateconf_free_lists(lists,

+ NUM_KEYS);

+

+ /* store current version to identify config data */

+ mate_panel_applet_mateconf_set_string(sensors_applet->applet,

+ SENSORS_APPLET_VERSION,

+ PACKAGE_VERSION, &error);

+

+ return TRUE;

+}

+

+/*

+ * Copyright (C) 2005-2009 Alex Murray <[email protected]>

+ *

+ * This program is free software; you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2 of the License, or

+ * (at your option) any later version.

+ *

+ * This program is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+ * GNU General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

+ */

+

+#ifndef SENSORS_APPLET_MATECONF_H

+#define SENSORS_APPLET_MATECONF_H

+

+#include "sensors-applet.h"

+#include <mate-panel-applet-mateconf.h>

+

+#define FONT_SIZE "font-size" /* hidden mateconf option specifying font

+ * size in points */

+

+#define HIDE_UNITS "hide-units" /* hidden mateconf option specifying not to

+ * show sensor units */

+

+#define IS_SETUP "setup" /* have we actually set up this instance of

+ * the applet (gets set to true after

+ * closing prefences dialog) */

+

+#define DISPLAY_MODE "display_mode" /* display icons or text labels?*/

+

+#define LAYOUT_MODE "layout_mode" /* value beside or below label */

+#define TEMPERATURE_SCALE "temperature_scale" /* Kelvin,

+ Celsius or

+ Fahrenheit */

+#define DISPLAY_NOTIFICATIONS "display_notifications" /* whether to

+ * display

+ * notifications */

+#define TIMEOUT "timeout_delay" /* delay (in ms) between refreshes */

+#define GRAPH_SIZE "graph_size" /* the size of the graph in pixels -

+ * either width if horizontal, or

+ * height if vertical */

+#define PATHS "paths" /* full paths to filenames */

+#define IDS "ids" /* a list of the sensor device ids */

+#define INTERFACES "interfaces" /* a list of the sensor device

+ * interface for each sensor */

+#define LABELS "labels" /* user defined labels for each sensor */

+#define ENABLES "sensor_enables" /* list of booleans corresponding to

+ * the filenames of whether a sensor

+ * is enabled or not */

+#define LOW_VALUES "low_values" /* stored as ints (1000 * double

+ * value) for accuracy, since can

+ * only do ints easily */

+#define HIGH_VALUES "high_values" /* stored as ints (1000 * double

+ * value) for accuracy, since can

+ * only do ints easily */

+#define ALARM_ENABLES "alarm_enables" /* list of whether each sensor

+ * has its alarm enabled */

+#define LOW_ALARM_COMMANDS "low_alarm_commands" /* list of commands to execute

+ * when each alarm is

+ * activated */

+#define HIGH_ALARM_COMMANDS "high_alarm_commands" /* list of commands to execute

+ * when each alarm is

+ * activated */

+

+#define ALARM_TIMEOUTS "alarm_timeouts" /* list of how often each

+ alarm should be sounded (in

+ seconds) */

+

+#define SENSOR_TYPES "sensor_types" /* used to identify a sensor in a

+ list */

+

+#define MULTIPLIERS "multipliers"

+#define OFFSETS "offsets"

+#define ICON_TYPES "icon_types"

+#define GRAPH_COLORS "graph_colors"

+

+#define SENSORS_APPLET_VERSION "sensors_applet_version" /* version of

+ * config

+ * data */

+

+gboolean sensors_applet_mateconf_save_sensors(SensorsApplet *sensors_applet);

+gboolean sensors_applet_mateconf_setup_sensors(SensorsApplet *sensors_applet);

+void sensors_applet_mateconf_setup(SensorsApplet *sensors_applet);

+

+#endif /* SENSORS_APPLET_MATECONF_H*/

+#define SENSORS_APPLET_USER_PLUGIN_DIR ".mate2/sensors-applet/plugins"

+#include <mate.h>

+#include "sensors-applet-mateconf.h"

+#ifdef HAVE_LIBMATENOTIFY

+#include "active-sensor-libmatenotify.h"

+static void prefs_cb(MateComponentUIComponent *uic,

+static void about_cb(MateComponentUIComponent *uic,

+static void help_cb(MateComponentUIComponent *uic,

+static void change_background_cb(MatePanelApplet *applet,

+ MatePanelAppletBackgroundType type,

+static void change_orient_cb (MatePanelApplet *applet,

+ MatePanelAppletOrient orient,

+static void size_allocate_cb(MatePanelApplet *applet,

+ MatePanelAppletOrient orient;

+ orient = mate_panel_applet_get_orient(sensors_applet->applet);

+ if ((orient == MATE_PANEL_APPLET_ORIENT_LEFT) ||

+ (orient == MATE_PANEL_APPLET_ORIENT_RIGHT)) {

+ display_mode = mate_panel_applet_mateconf_get_int(sensors_applet->applet,

+static const MateComponentUIVerb sensors_applet_menu_verbs[] = {

+ MATECOMPONENT_UI_UNSAFE_VERB("Preferences", prefs_cb),

+ MATECOMPONENT_UI_UNSAFE_VERB ("Help", help_cb),

+ MATECOMPONENT_UI_UNSAFE_VERB("About", about_cb),

+ MATECOMPONENT_UI_VERB_END

+#ifdef HAVE_LIBMATENOTIFY

+#endif // HAVE_LIBMATENOTIFY

+#ifdef HAVE_LIBMATENOTIFY

+ case MATECONF_READ_ERROR:

+ case MATECONF_WRITE_ERROR:

+#endif // HAVE_LIBMATENOTIFY

+#ifdef HAVE_LIBMATENOTIFY

+ if (!mate_panel_applet_mateconf_get_bool(sensors_applet->applet,

+ temp_scale = (TemperatureScale)mate_panel_applet_mateconf_get_int(active_sensor->sensors_applet->applet,

+ timeout_msecs = mate_panel_applet_mateconf_get_int(active_sensor->sensors_applet->applet,

+ active_sensor_libmatenotify_notify(active_sensor,

+#ifdef HAVE_LIBMATENOTIFY

+ active_sensor_libmatenotify_notify_end(active_sensor, notif_type);

+#ifdef HAVE_LIBMATENOTIFY

+ active_sensor_libmatenotify_notify_end(active_sensor, LOW_ALARM);

+ active_sensor_libmatenotify_notify_end(active_sensor, HIGH_ALARM);

+#ifdef HAVE_LIBMATENOTIFY

+ display_mode = (DisplayMode)mate_panel_applet_mateconf_get_int(sensors_applet->applet,

+ layout_mode = (LayoutMode)mate_panel_applet_mateconf_get_int(sensors_applet->applet,

+ horizontal = (((mate_panel_applet_get_orient(sensors_applet->applet) == MATE_PANEL_APPLET_ORIENT_UP) ||

+ (mate_panel_applet_get_orient(sensors_applet->applet) == MATE_PANEL_APPLET_ORIENT_DOWN)));

+ graph_size = mate_panel_applet_mateconf_get_int(sensors_applet->applet,

+ if (mate_panel_applet_get_orient(sensors_applet->applet) ==

+ MATE_PANEL_APPLET_ORIENT_UP ||

+ mate_panel_applet_get_orient(sensors_applet->applet) ==

+ MATE_PANEL_APPLET_ORIENT_DOWN) {

+ mate_panel_applet_set_flags(sensors_applet->applet,

+ MATE_PANEL_APPLET_EXPAND_MINOR);

+ /* if not setup, write defaults to mateconf */

+ sensors_applet_mateconf_setup(sensors_applet);

+ mate_panel_applet_setup_menu_from_file(sensors_applet->applet,

+ sensors_applet->timeout_id = g_timeout_add_seconds(mate_panel_applet_mateconf_get_int(sensors_applet->applet, TIMEOUT, NULL) / 1000,

+#include <mate-panel-applet.h>

+#ifdef HAVE_LIBMATENOTIFY

+#include <libmatenotify/notify.h>

+ * structure and to access specific mateconf keys too.

+ MATECONF_READ_ERROR,

+ MATECONF_WRITE_ERROR,

+ MatePanelApplet* applet;

+#ifdef HAVE_LIBMATENOTIFY

+#endif // HAVE_LIBMATENOTIFY