/* * Copyright (C) 2005 Alex Murray * * 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 */ /** Contain the functions for operating on the SensorsApplet structure * (represents the applet itself, and its associated variables. */ #ifdef HAVE_CONFIG_H #include "config.h" #endif /* HAVE_CONFIG_H */ #include #include #include "sensors-applet.h" #include "active-sensor.h" #include "sensors-applet-gconf.h" /* use libsensors if available, otherwise manually find sensors */ #ifdef HAVE_LIBSENSORS #include "libsensors-sensors-interface.h" #endif #include "mbmon-sensors-interface.h" #include "smartctl-sensors-interface.h" #include "prefs-dialog.h" #include "about-dialog.h" #define SENSORS_APPLET_MENU_FILE "SensorsApplet.xml" #define DEFAULT_TIMEOUT 2000 /* callbacks for panel menu */ static void prefs_cb(BonoboUIComponent *uic, SensorsApplet *sensors_applet, const gchar *verbname) { if (sensors_applet->prefs_dialog) { gtk_window_present(GTK_WINDOW(sensors_applet->prefs_dialog)); return; } prefs_dialog_open(sensors_applet); } static void about_cb(BonoboUIComponent *uic, SensorsApplet *sensors_applet, const gchar *verbname) { #ifndef HAVE_GTK_26 if (sensors_applet->about_dialog) { gtk_window_present(GTK_WINDOW(sensors_applet->about_dialog)); return; } #endif /* HAVE_GTK_26 */ about_dialog_open(sensors_applet); } static void help_cb (BonoboUIComponent *uic, SensorsApplet *sensors_applet, const gchar *verbname) { GError *error = NULL; gnome_help_display(PACKAGE, NULL, &error); if (error) { g_debug("Could not open help document: %s\n ",error->message); g_error_free (error); } } static void destroy_cb(GtkWidget *widget, SensorsApplet *sensors_applet) { /* destory sensors tree and dialogs and finally the applet */ if (sensors_applet->timeout_id) { g_source_remove(sensors_applet->timeout_id); } if (sensors_applet->sensors != NULL) { gtk_tree_store_clear(sensors_applet->sensors); } if (sensors_applet->prefs_dialog != NULL) { gtk_widget_destroy(GTK_WIDGET(sensors_applet->prefs_dialog)); } gtk_widget_destroy(GTK_WIDGET(sensors_applet->applet)); g_free(sensors_applet); return; } static void change_background_cb(PanelApplet *applet, PanelAppletBackgroundType type, GdkColor *color, GdkPixmap *pixmap, SensorsApplet *sensors_applet) { GtkRcStyle *rc_style; GtkStyle *style; g_assert(applet == sensors_applet->applet); /* reset style */ gtk_widget_set_style(GTK_WIDGET(applet), NULL); rc_style = gtk_rc_style_new(); gtk_widget_modify_style(GTK_WIDGET(applet), rc_style); gtk_rc_style_unref(rc_style); switch(type) { case PANEL_COLOR_BACKGROUND: gtk_widget_modify_bg(GTK_WIDGET(applet), GTK_STATE_NORMAL, color); break; case PANEL_PIXMAP_BACKGROUND: style = gtk_style_copy(GTK_WIDGET(applet)->style); if (style->bg_pixmap[GTK_STATE_NORMAL]) { g_object_unref(style->bg_pixmap[GTK_STATE_NORMAL]); } style->bg_pixmap[GTK_STATE_NORMAL] = g_object_ref(pixmap); gtk_widget_set_style(GTK_WIDGET(applet), style); g_object_unref(style); break; case PANEL_NO_BACKGROUND: /* fall through */ default: break; } } static const BonoboUIVerb sensors_applet_menu_verbs[] = { BONOBO_UI_UNSAFE_VERB("Preferences", prefs_cb), BONOBO_UI_UNSAFE_VERB ("Help", help_cb), BONOBO_UI_UNSAFE_VERB("About", about_cb), BONOBO_UI_VERB_END }; /* functions to be called by the different sensors intefaces */ void sensors_applet_register_sensors_interface(SensorsApplet *sensors_applet, SensorInterface interface, GetSensorValueFunction get_sensor_value_function) { sensors_applet->get_sensor_value[interface] = get_sensor_value_function; } gboolean sensors_applet_add_sensor_full_details(SensorsApplet *sensors_applet, const gchar *path, const gchar *id, const gchar *label, SensorInterface interface, SensorType type, gboolean enable, gdouble alarm_value, AlarmType alarm_type, gboolean alarm_enable, const gchar *alarm_command, gint alarm_timeout, gdouble multiplier, gdouble offset, const gchar *icon_filename) { GtkTreeIter interfaces_iter, sensors_iter; gboolean not_empty_tree; /* assign to UNUSED to ensure we dont accidently match an * interface that doesnt actually exist */ guint node_interface = UNUSED; gboolean not_end_of_interfaces = TRUE, interface_exists = FALSE; gboolean not_end_of_sensors = TRUE; gchar *sensor_id; GdkPixbuf *icon; GError *error = NULL; GtkTreePath *tree_path; GtkTreeRowReference *row; ActiveSensor *active_sensor; g_assert(sensors_applet != NULL); /* assume tree is not empty */ not_empty_tree = TRUE; if (NULL == sensors_applet->sensors) { sensors_applet->sensors = gtk_tree_store_new(N_COLUMNS, G_TYPE_STRING, /* path */ G_TYPE_STRING, /* id */ G_TYPE_STRING, /* label */ G_TYPE_UINT, /* interface */ G_TYPE_UINT, /* sensor * type */ G_TYPE_BOOLEAN, /* enable */ G_TYPE_BOOLEAN, /* visible */ G_TYPE_DOUBLE, /* alarm value */ G_TYPE_UINT, /* alarm type */ G_TYPE_BOOLEAN, /* alarm enable */ G_TYPE_STRING, /* alarm command */ G_TYPE_UINT, /* alarm timeout */ G_TYPE_DOUBLE, /* multiplier */ G_TYPE_DOUBLE, /* offset */ G_TYPE_STRING, /* icon filename */ GDK_TYPE_PIXBUF); /* icon pixbuf */ g_debug("Sensor tree created.\n"); /* we know tree is actually empty since we just created it */ not_empty_tree = FALSE; } /* search sensor tree for the parent interface to place this * sensor under */ for (not_empty_tree = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(sensors_applet->sensors), &interfaces_iter); not_empty_tree && not_end_of_interfaces && !interface_exists; not_end_of_interfaces = gtk_tree_model_iter_next(GTK_TREE_MODEL(sensors_applet->sensors), &interfaces_iter)) { gtk_tree_model_get(GTK_TREE_MODEL(sensors_applet->sensors), &interfaces_iter, INTERFACE_COLUMN, &node_interface, -1); if (interface == node_interface) { /* found interface in tree */ interface_exists = TRUE; /* now see if this actual sensor already * exists within this interface - don't want * to add duplicates */ /* see if have children */ for (not_end_of_sensors = gtk_tree_model_iter_children(GTK_TREE_MODEL(sensors_applet->sensors), &sensors_iter, &interfaces_iter); not_end_of_sensors; not_end_of_sensors = gtk_tree_model_iter_next(GTK_TREE_MODEL(sensors_applet->sensors), &sensors_iter)) { gtk_tree_model_get(GTK_TREE_MODEL(sensors_applet->sensors), &sensors_iter, ID_COLUMN, &sensor_id, -1); if (g_ascii_strcasecmp(sensor_id, id) == 0) { /* sensor already exists so * dont add a second time */ g_debug("sensor already exists in tree, not adding a second time: %s\n", sensor_id); g_free(sensor_id); return FALSE; } g_free(sensor_id); } break; } } if (!interface_exists) { /* wasn't able to find interface root node so create it */ gtk_tree_store_append(sensors_applet->sensors, &interfaces_iter, NULL); gtk_tree_store_set(sensors_applet->sensors, &interfaces_iter, ID_COLUMN, sensor_interface[interface], INTERFACE_COLUMN, interface, VISIBLE_COLUMN, FALSE, -1); } /* try to load the icon */ g_debug("loading icon %s\n", icon_filename); icon = gdk_pixbuf_new_from_file_at_size(icon_filename, DEFAULT_ICON_SIZE, DEFAULT_ICON_SIZE, &error); if (error) { g_warning ("Could not load icon: %s\nTrying with default icon.\n", error->message); g_error_free(error); error = NULL; /* try again with default name */ icon_filename = SENSORS_APPLET_ICON; icon = gdk_pixbuf_new_from_file_at_size(icon_filename, DEFAULT_ICON_SIZE, DEFAULT_ICON_SIZE, &error); if (error) { g_warning ("Could not load icon: %s\n", error->message); g_error_free(error); error = NULL; return; } } /* then add sensor as a child under interface node - ie assume * we either found it or created it - the inteface node that * is */ /* for now just add sensors all in a single list */ gtk_tree_store_append(sensors_applet->sensors, &sensors_iter, &interfaces_iter); gtk_tree_store_set(sensors_applet->sensors, &sensors_iter, PATH_COLUMN, path, ID_COLUMN, id, LABEL_COLUMN, label, INTERFACE_COLUMN, interface, SENSOR_TYPE_COLUMN, type, ENABLE_COLUMN, enable, VISIBLE_COLUMN, TRUE, ALARM_VALUE_COLUMN, alarm_value, ALARM_TYPE_COLUMN, alarm_type, ALARM_ENABLE_COLUMN, alarm_enable, ALARM_COMMAND_COLUMN, alarm_command, ALARM_TIMEOUT_COLUMN, alarm_timeout, MULTIPLIER_COLUMN, multiplier, OFFSET_COLUMN, offset, ICON_FILENAME_COLUMN, icon_filename, ICON_PIXBUF_COLUMN, icon, -1); /* remove reference to icon as tree now has ref */ g_object_unref(icon); /* create the active sensor */ if (enable) { tree_path = gtk_tree_model_get_path(GTK_TREE_MODEL(sensors_applet->sensors), &sensors_iter); sensors_applet_sensor_enabled(sensors_applet, tree_path); gtk_tree_path_free(tree_path); } } static ActiveSensor *sensors_applet_find_active_sensor(SensorsApplet *sensors_applet, GtkTreePath *path) { GtkTreePath *sensor_tree_path; GList *current_sensor; for (current_sensor = sensors_applet->active_sensors; current_sensor != NULL; current_sensor = g_list_next(current_sensor)) { sensor_tree_path = gtk_tree_row_reference_get_path(((ActiveSensor *)(current_sensor->data))->sensor_row); if (gtk_tree_path_compare(path, sensor_tree_path) == 0) { g_debug("found AS...\n"); return ((ActiveSensor *)(current_sensor->data)); } } return NULL; } /* path should be the full path to a file representing the sensor (eg * /dev/hda or /sys/devices/platform/i2c-0/0-0290/temp1_input) */ gboolean sensors_applet_add_sensor(SensorsApplet *sensors_applet, const gchar *path, const gchar *id, const gchar *label, SensorInterface interface, gboolean enable, SensorType type, const gchar *icon_filename) { g_assert(sensors_applet != NULL); if (icon_filename == NULL) { icon_filename = SENSORS_APPLET_ICON; } return sensors_applet_add_sensor_full_details(sensors_applet, path, id, label, interface, type, enable, 0.0, ALARM_WHEN_VALUE_GREATER_THAN_THRESHOLD, FALSE, "", 0, 1.0, 0.0, icon_filename); } /* internal helper functions for updating display etc*/ /* should be called as a g_container_foreach at the start of * pack_display if ythe table already exists to remove but keep alive * all children of the table before repacking it */ static void sensors_applet_pack_display_empty_table_cb(GtkWidget *widget, gpointer data) { GtkContainer *container = GTK_CONTAINER(data); /* ref then remove widget */ g_object_ref(widget); gtk_container_remove(container, widget); } /* should be called as a g_container_foreach at the end of * pack_display to unref any of the old children that we have readdded * to the table to stop reference creep from the g_object_ref called * on each child at the start of pack labels */ static void sensors_applet_pack_display_cleanup_refs_cb(GtkWidget *widget, gpointer data) { GList *old_children = (GList *)data; if (g_list_find(old_children, widget)) { g_object_unref(widget); } } static void sensors_applet_pack_display(SensorsApplet *sensors_applet) { /* note the if () around each widget is to ensure we only * operate on those that actually exist */ static GtkLabel *no_sensors_enabled_label = NULL; gint num_active_sensors = 0, num_sensors_per_group, cols, rows, i, j; GList *old_table_children = NULL; GList *current_sensor; gint display_mode; num_active_sensors = g_list_length(sensors_applet->active_sensors); display_mode = panel_applet_gconf_get_int(sensors_applet->applet, DISPLAY_MODE, NULL); num_sensors_per_group = panel_applet_gconf_get_int(sensors_applet->applet, NUM_SENSORS, NULL); if (panel_applet_get_orient(sensors_applet->applet) == PANEL_APPLET_ORIENT_UP || panel_applet_get_orient(sensors_applet->applet) == PANEL_APPLET_ORIENT_DOWN) { /* if oriented horizontally, want as many sensors per column as user has defined, then enough columns to hold all the values */ rows = num_sensors_per_group; cols = num_active_sensors / num_sensors_per_group; while (rows * cols < num_active_sensors || cols == 0) { cols++; } } else { /* if oriented vertically, want as many sensors per row as user has defined, then enough rows to hold all the labels */ cols = num_sensors_per_group; rows = num_active_sensors / num_sensors_per_group; while (rows * cols < num_active_sensors || rows == 0) { rows++; } } /* if displaying labels need to modify number of rows / colums to accomodate this */ if (display_mode != DISPLAY_NONE) { if (panel_applet_gconf_get_bool(sensors_applet->applet, LABELS_INLINE, NULL)) { /* to display labels next to values need twice as many columns */ cols *= 2; } else { /* to display labels above values, we need * twice as many rows as without */ rows *= 2; } } if (sensors_applet->table == NULL) { /* create table and add to applet */ sensors_applet->table = gtk_table_new(rows, cols, FALSE); gtk_table_set_col_spacings(GTK_TABLE(sensors_applet->table), 3); gtk_table_set_row_spacings(GTK_TABLE(sensors_applet->table), 0); gtk_container_add(GTK_CONTAINER(sensors_applet->applet), sensors_applet->table); } else { /* remove all children if table already exists so we can start * again */ /* save a list of the old children for later */ old_table_children = gtk_container_get_children(GTK_CONTAINER(sensors_applet->table)); gtk_container_foreach(GTK_CONTAINER(sensors_applet->table), sensors_applet_pack_display_empty_table_cb, sensors_applet->table); /* then resize table */ gtk_table_resize(GTK_TABLE(sensors_applet->table), rows, cols); } /* if no active sensors, display a label to this effect and return */ if (num_active_sensors == 0) { if (no_sensors_enabled_label == NULL) { no_sensors_enabled_label = g_object_new(GTK_TYPE_LABEL, "label", _("No sensors enabled!"), NULL); } gtk_table_attach_defaults(GTK_TABLE(sensors_applet->table), GTK_WIDGET(no_sensors_enabled_label), 0, 1, 0, 1); } /* pack icons / labels and values into table */ current_sensor = sensors_applet->active_sensors; /* if showing labels need to pack these first */ if (display_mode != DISPLAY_NONE) { /* loop through columns */ for (i = 0; current_sensor != NULL && i < cols; /* increments depends on how we lay them out - see below */) { /* loop through rows in a column */ for (j = 0; current_sensor && j < rows; /* see bottom of for loop*/) { /* attach label / icon at this point */ if (display_mode == DISPLAY_ICON) { if (((ActiveSensor *)(current_sensor->data))->icon) { gtk_table_attach_defaults(GTK_TABLE(sensors_applet->table), GTK_WIDGET(((ActiveSensor *)(current_sensor->data))->icon), i, i + 1, j, j + 1); } } else { if (((ActiveSensor *)(current_sensor->data))->label) { gtk_table_attach_defaults(GTK_TABLE(sensors_applet->table), GTK_WIDGET(((ActiveSensor *)(current_sensor->data))->label), i, i + 1, j, j + 1); } } /* now attach sensor value to either row below or column next to */ if (panel_applet_gconf_get_bool(sensors_applet->applet, LABELS_INLINE, NULL)) { /* left align labels */ if (((ActiveSensor *)(current_sensor->data))->icon) { gtk_misc_set_alignment(GTK_MISC(((ActiveSensor *)(current_sensor->data))->icon), 0.0, 0.5); } if (((ActiveSensor *)(current_sensor->data))->label) { gtk_misc_set_alignment(GTK_MISC(((ActiveSensor *)(current_sensor->data))->label), 0.0, 0.5); } if (((ActiveSensor *)(current_sensor->data))->value) { gtk_misc_set_alignment(GTK_MISC(((ActiveSensor *)(current_sensor->data))->value), 0.0, 0.5); } /* place value next to label */ if (((ActiveSensor *)(current_sensor->data))->value) { gtk_table_attach_defaults(GTK_TABLE(sensors_applet->table), GTK_WIDGET(((ActiveSensor *)(current_sensor->data))->value), i + 1, i + 2, j, j + 1); } j++; } else { /* place value below label */ /* center align labels */ if (((ActiveSensor *)(current_sensor->data))->icon) { gtk_misc_set_alignment(GTK_MISC(((ActiveSensor *)(current_sensor->data))->icon), 0.5, 0.5); } if (((ActiveSensor *)(current_sensor->data))->label) { gtk_misc_set_alignment(GTK_MISC(((ActiveSensor *)(current_sensor->data))->label), 0.5, 0.5); } if (((ActiveSensor *)(current_sensor->data))->value) { gtk_misc_set_alignment(GTK_MISC(((ActiveSensor *)(current_sensor->data))->value), 0.5, 0.5); } if (((ActiveSensor *)(current_sensor->data))->value) { gtk_table_attach_defaults(GTK_TABLE(sensors_applet->table), GTK_WIDGET(((ActiveSensor *)(current_sensor->data))->value), i, i + 1, j + 1, j + 2); } j += 2; } current_sensor = g_list_next(current_sensor); } /* end row loop */ /* now increment column index as needed */ if (panel_applet_gconf_get_bool(sensors_applet->applet, LABELS_INLINE, NULL)) { /* place value next to label */ i += 2; } else { i++; } } /* end column loop */ } else { /* not showing labels or icons so just pack values */ for (i = 0; current_sensor != NULL && i < cols; ++i) { for (j = 0; current_sensor!= NULL && j < rows; ++j) { if (((ActiveSensor *)(current_sensor->data))->value) { gtk_table_attach_defaults(GTK_TABLE(sensors_applet->table), GTK_WIDGET(((ActiveSensor *)(current_sensor->data))->value), i, i + 1, j, j + 1); } current_sensor = g_list_next(current_sensor); } } } if (old_table_children != NULL) { gtk_container_foreach(GTK_CONTAINER(sensors_applet->table), sensors_applet_pack_display_cleanup_refs_cb, old_table_children); g_list_free(old_table_children); } gtk_widget_show_all(GTK_WIDGET(sensors_applet->applet)); } void sensors_applet_display_layout_changed(SensorsApplet *sensors_applet) { sensors_applet_pack_display(sensors_applet); } void sensors_applet_alarm_off(SensorsApplet *sensors_applet, GtkTreePath *path) { ActiveSensor *active_sensor; if ((active_sensor = sensors_applet_find_active_sensor(sensors_applet, path)) != NULL) { active_sensor_alarm_off(active_sensor, path); } } void sensors_applet_sensor_enabled(SensorsApplet *sensors_applet, GtkTreePath *path) { ActiveSensor *active_sensor; g_debug("creating new active sensor\n"); g_assert(sensors_applet != NULL); g_assert(path != NULL); active_sensor = g_new0(ActiveSensor, 1); active_sensor->sensor_row = gtk_tree_row_reference_new(GTK_TREE_MODEL(sensors_applet->sensors), path); active_sensor->alarm_timeout_id = -1; /* keep list sorted */ sensors_applet->active_sensors = g_list_insert_sorted(sensors_applet->active_sensors, active_sensor, (GCompareFunc)active_sensor_compare); active_sensor_update(active_sensor, sensors_applet); sensors_applet_pack_display(sensors_applet); } void sensors_applet_sensor_disabled(SensorsApplet *sensors_applet, GtkTreePath *path) { GtkTreeModel *model; ActiveSensor *active_sensor; g_assert(sensors_applet != NULL); g_assert(path != NULL); if ((active_sensor = sensors_applet_find_active_sensor(sensors_applet, path)) != NULL) { g_debug("Destroying active sensor...\n"); g_debug("-- removing from list...\n"); sensors_applet->active_sensors = g_list_remove(sensors_applet->active_sensors, active_sensor); g_debug("-- repacking display....\n"); sensors_applet_pack_display(sensors_applet); /* destroy the current_sensor */ g_debug("-- destroying active sensor label...\n"); gtk_object_destroy(GTK_OBJECT(active_sensor->label)); g_debug("-- destroying active sensor icon...\n"); gtk_object_destroy(GTK_OBJECT(active_sensor->icon)); g_debug("-- destroying active sensor value...\n"); gtk_object_destroy(GTK_OBJECT(active_sensor->value)); if (active_sensor->alarm_timeout_id >= 0) { active_sensor_alarm_off(active_sensor); } g_free(active_sensor); } } void sensors_applet_update_sensor(SensorsApplet *sensors_applet, GtkTreePath *path) { ActiveSensor *active_sensor; g_assert(sensors_applet != NULL); g_assert(path != NULL); if ((active_sensor = sensors_applet_find_active_sensor(sensors_applet, path)) != NULL) { active_sensor_update(active_sensor, sensors_applet); } } void sensors_applet_icon_changed(SensorsApplet *sensors_applet, GtkTreePath *path) { ActiveSensor *active_sensor; g_assert(sensors_applet != NULL); g_assert(path != NULL); if ((active_sensor = sensors_applet_find_active_sensor(sensors_applet, path)) != NULL) { active_sensor_icon_changed(active_sensor, sensors_applet); } } /** * Cycle thru ActiveSensors and update them all */ void sensors_applet_update_active_sensors(SensorsApplet *sensors_applet) { gchar *tooltip; unsigned long int num_active_sensors; g_assert(sensors_applet != NULL); g_assert(sensors_applet->active_sensors != NULL); num_active_sensors = (unsigned long int)g_list_length(sensors_applet->active_sensors); g_list_foreach(sensors_applet->active_sensors, (GFunc)active_sensor_update, sensors_applet); tooltip = g_strdup_printf("%s\n%d %s", _("Sensors Applet"), num_active_sensors, ngettext(_("sensor enabled"), _("sensors enabled"), num_active_sensors)); gtk_tooltips_set_tip(sensors_applet->tooltips, GTK_WIDGET(sensors_applet->applet), tooltip, ""); g_free(tooltip); return; } static void sensors_applet_write_defaults_to_gconf(SensorsApplet *sensors_applet) { panel_applet_gconf_set_bool(sensors_applet->applet, FARENHEIT, FALSE, NULL); panel_applet_gconf_set_int(sensors_applet->applet, NUM_SENSORS, 1, NULL); panel_applet_gconf_set_int(sensors_applet->applet, DISPLAY_MODE, DISPLAY_LABEL, NULL); panel_applet_gconf_set_bool(sensors_applet->applet, LABELS_INLINE, TRUE, NULL); panel_applet_gconf_set_bool(sensors_applet->applet, SHOW_UNITS, TRUE, NULL); panel_applet_gconf_set_int(sensors_applet->applet, TIMEOUT, DEFAULT_TIMEOUT, NULL); panel_applet_gconf_set_int(sensors_applet->applet, FONT_SIZE, MEDIUM, NULL); panel_applet_gconf_set_bool(sensors_applet->applet, IS_SETUP, FALSE, NULL); } static void sensors_applet_setup_sensors_interfaces(SensorsApplet *sensors_applet) { #ifdef HAVE_LIBSENSORS libsensors_sensors_interface_init(sensors_applet); #endif mbmon_sensors_interface_init(sensors_applet); smartctl_sensors_interface_init(sensors_applet); } void sensors_applet_init(SensorsApplet *sensors_applet) { g_assert(sensors_applet); g_assert(sensors_applet->applet); panel_applet_set_flags(sensors_applet->applet, PANEL_APPLET_EXPAND_MINOR); panel_applet_setup_menu_from_file(sensors_applet->applet, DATADIR, SENSORS_APPLET_MENU_FILE, NULL, sensors_applet_menu_verbs, sensors_applet); g_signal_connect(sensors_applet->applet, "change_background", G_CALLBACK(change_background_cb), sensors_applet); g_signal_connect(sensors_applet->applet, "destroy", G_CALLBACK(destroy_cb), sensors_applet); /* if not setup, write defaults to gconf */ if (!panel_applet_gconf_get_bool(sensors_applet->applet, IS_SETUP, NULL)) { sensors_applet_write_defaults_to_gconf(sensors_applet); } else { /* setup sensors from stored gconf values */ sensors_applet_gconf_setup_sensors(sensors_applet); g_debug("done setting up from gconf\n"); } /* now do any setup needed manually */ sensors_applet_setup_sensors_interfaces(sensors_applet); /* should have created sensors tree above, but if have not was because we couldn't find any sensors */ if (NULL == sensors_applet->sensors) { GtkWidget *label; label = gtk_label_new(_("No sensors found!")); gtk_container_add(GTK_CONTAINER(sensors_applet->applet), label); gtk_widget_show_all(GTK_WIDGET(sensors_applet->applet)); return; } sensors_applet->tooltips = gtk_tooltips_new(); gtk_tooltips_set_tip(sensors_applet->tooltips, GTK_WIDGET(sensors_applet->applet), _("Sensors Applet"), ""); sensors_applet_update_active_sensors(sensors_applet); sensors_applet_pack_display(sensors_applet); sensors_applet->timeout_id = g_timeout_add(panel_applet_gconf_get_int(sensors_applet->applet, TIMEOUT, NULL), (GSourceFunc)sensors_applet_update_active_sensors, sensors_applet); gtk_widget_show_all(GTK_WIDGET(sensors_applet->applet)); }