summaryrefslogtreecommitdiff
path: root/sensors-applet/prefs-dialog.c
diff options
context:
space:
mode:
authorStefano Karapetsas <[email protected]>2011-11-21 23:44:15 +0100
committerStefano Karapetsas <[email protected]>2011-11-21 23:44:15 +0100
commit69ecddf1317e71f35b1c1de00392dc76f8f1701c (patch)
treeaba29401d8d4b88f14d67aac2b0e60980a78fa2e /sensors-applet/prefs-dialog.c
downloadmate-sensors-applet-69ecddf1317e71f35b1c1de00392dc76f8f1701c.tar.bz2
mate-sensors-applet-69ecddf1317e71f35b1c1de00392dc76f8f1701c.tar.xz
Initial release bases on sensors-applet
Diffstat (limited to 'sensors-applet/prefs-dialog.c')
-rw-r--r--sensors-applet/prefs-dialog.c1009
1 files changed, 1009 insertions, 0 deletions
diff --git a/sensors-applet/prefs-dialog.c b/sensors-applet/prefs-dialog.c
new file mode 100644
index 0000000..fc7d3ac
--- /dev/null
+++ b/sensors-applet/prefs-dialog.c
@@ -0,0 +1,1009 @@
+/*
+ * 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 <libgnome/libgnome.h>
+#include "sensors-applet-gconf.h"
+#include "prefs-dialog.h"
+#include "sensor-config-dialog.h"
+
+#define OLD_TEMP_SCALE 0
+#define NEW_TEMP_SCALE 1
+
+/* when a user closes the prefs-dialog we assume that applet is now
+ setup, so store all values in gconf */
+void prefs_dialog_close(SensorsApplet *sensors_applet) {
+
+ if (sensors_applet->sensors != NULL) {
+ if (sensors_applet_gconf_save_sensors(sensors_applet))
+ panel_applet_gconf_set_bool(sensors_applet->applet,
+ IS_SETUP, TRUE, NULL);
+ }
+ if (sensors_applet->prefs_dialog) {
+ gtk_widget_destroy(GTK_WIDGET(sensors_applet->prefs_dialog->dialog));
+ g_free(sensors_applet->prefs_dialog);
+ sensors_applet->prefs_dialog = NULL;
+
+ }
+ if (sensors_applet->timeout_id == 0) {
+ sensors_applet->timeout_id = g_timeout_add_seconds(panel_applet_gconf_get_int(sensors_applet->applet, TIMEOUT, NULL) / 1000, (GSourceFunc)sensors_applet_update_active_sensors, sensors_applet);
+ }
+
+
+}
+
+void prefs_dialog_response(GtkDialog *prefs_dialog,
+ gint response,
+ gpointer data) {
+
+ SensorsApplet *sensors_applet;
+ GError *error = NULL;
+ gint current_page;
+ gchar *uri;
+
+ sensors_applet = (SensorsApplet *)data;
+
+ switch (response) {
+ case GTK_RESPONSE_HELP:
+ g_debug("loading help in prefs");
+ current_page = gtk_notebook_get_current_page(sensors_applet->prefs_dialog->notebook);
+ uri = g_strdup_printf("ghelp:sensors-applet?%s",
+ ((current_page == 0) ?
+ "sensors-applet-general-options" :
+ ((current_page == 1) ?
+ "sensors-applet-sensors" :
+ NULL)));
+ gtk_show_uri(NULL, uri, gtk_get_current_event_time(), &error);
+ g_free(uri);
+
+ if (error) {
+ g_debug("Could not open help document: %s ",error->message);
+ g_error_free (error);
+ }
+ break;
+ default:
+ g_debug("closing prefs dialog");
+ prefs_dialog_close(sensors_applet);
+ }
+}
+
+
+static gboolean prefs_dialog_convert_low_and_high_values(GtkTreeModel *model,
+ GtkTreePath *path,
+ GtkTreeIter *iter,
+ TemperatureScale scales[2]) {
+ SensorType sensor_type;
+ gdouble low_value, high_value;
+
+ gtk_tree_model_get(model,
+ iter,
+ SENSOR_TYPE_COLUMN, &sensor_type,
+ LOW_VALUE_COLUMN, &low_value,
+ HIGH_VALUE_COLUMN, &high_value,
+ -1);
+
+ if (sensor_type == TEMP_SENSOR)
+ {
+ low_value = sensors_applet_convert_temperature(low_value,
+ scales[OLD_TEMP_SCALE],
+ scales[NEW_TEMP_SCALE]);
+
+ high_value = sensors_applet_convert_temperature(high_value,
+ scales[OLD_TEMP_SCALE],
+ scales[NEW_TEMP_SCALE]);
+
+
+ gtk_tree_store_set(GTK_TREE_STORE(model),
+ iter,
+ LOW_VALUE_COLUMN, low_value,
+ HIGH_VALUE_COLUMN, high_value,
+ -1);
+ }
+ return FALSE;
+}
+
+
+static void prefs_dialog_timeout_changed(GtkSpinButton *button,
+ PrefsDialog *prefs_dialog) {
+ gint value;
+ value = (gint)(gtk_spin_button_get_value(button) * 1000);
+ panel_applet_gconf_set_int(prefs_dialog->sensors_applet->applet, TIMEOUT, value, NULL);
+}
+
+static void prefs_dialog_display_mode_changed(GtkComboBox *display_mode_combo_box,
+ PrefsDialog *prefs_dialog) {
+
+ int display_mode;
+
+ display_mode = gtk_combo_box_get_active(display_mode_combo_box);
+
+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->layout_mode_label),
+ (display_mode != DISPLAY_ICON) &&
+ (display_mode != DISPLAY_VALUE) &&
+ (display_mode != DISPLAY_GRAPH));
+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->layout_mode_combo_box),
+ (display_mode != DISPLAY_ICON) &&
+ (display_mode != DISPLAY_VALUE) &&
+ (display_mode != DISPLAY_GRAPH));
+
+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->graph_size_label),
+ (display_mode == DISPLAY_GRAPH));
+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->graph_size_spinbutton),
+ (display_mode == DISPLAY_GRAPH));
+
+ panel_applet_gconf_set_int(prefs_dialog->sensors_applet->applet,
+ DISPLAY_MODE,
+ gtk_combo_box_get_active(display_mode_combo_box),
+ NULL);
+
+ sensors_applet_display_layout_changed(prefs_dialog->sensors_applet);
+}
+
+static void prefs_dialog_layout_mode_changed(GtkComboBox *layout_mode_combo_box,
+ PrefsDialog *prefs_dialog) {
+
+ panel_applet_gconf_set_int(prefs_dialog->sensors_applet->applet,
+ LAYOUT_MODE,
+ gtk_combo_box_get_active(layout_mode_combo_box),
+ NULL);
+
+ sensors_applet_display_layout_changed(prefs_dialog->sensors_applet);
+}
+
+
+static void prefs_dialog_temperature_scale_changed(GtkComboBox *temperature_scale_combo_box,
+ PrefsDialog *prefs_dialog) {
+ /* get old temp scale value */
+ TemperatureScale scales[2];
+ GtkTreeModel *model;
+
+ scales[OLD_TEMP_SCALE] = (TemperatureScale)panel_applet_gconf_get_int(prefs_dialog->sensors_applet->applet,
+ TEMPERATURE_SCALE,
+ NULL);
+
+ scales[NEW_TEMP_SCALE] = (TemperatureScale)gtk_combo_box_get_active(temperature_scale_combo_box);
+
+ panel_applet_gconf_set_int(prefs_dialog->sensors_applet->applet,
+ TEMPERATURE_SCALE,
+ scales[NEW_TEMP_SCALE],
+ NULL);
+
+ /* now go thru and convert all low and high sensor values in
+ * the tree to either celcius or Fahrenheit */
+ model = gtk_tree_view_get_model(prefs_dialog->view);
+ gtk_tree_model_foreach(model,
+ (GtkTreeModelForeachFunc)prefs_dialog_convert_low_and_high_values,
+ scales);
+
+ /* finally update display of active sensors */
+ sensors_applet_update_active_sensors(prefs_dialog->sensors_applet);
+}
+
+
+#ifdef HAVE_LIBNOTIFY
+static void prefs_dialog_display_notifications_toggled(GtkCheckButton *display_notifications,
+ PrefsDialog *prefs_dialog) {
+
+ gboolean notify;
+
+ notify = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(display_notifications));
+ panel_applet_gconf_set_bool(prefs_dialog->sensors_applet->applet,
+ DISPLAY_NOTIFICATIONS,
+ notify,
+ NULL);
+
+ if (notify) {
+ sensors_applet_update_active_sensors(prefs_dialog->sensors_applet);
+ } else {
+ sensors_applet_notify_end_all(prefs_dialog->sensors_applet);
+ }
+}
+#endif
+
+static void prefs_dialog_graph_size_changed(GtkSpinButton *button,
+ PrefsDialog *prefs_dialog) {
+ gint value;
+ value = (gint)(gtk_spin_button_get_value(button));
+ panel_applet_gconf_set_int(prefs_dialog->sensors_applet->applet, GRAPH_SIZE, value, NULL);
+
+ /* notify change of number of samples */
+ sensors_applet_graph_size_changed(prefs_dialog->sensors_applet);
+
+}
+
+/* callbacks for the tree of sensors */
+static void prefs_dialog_sensor_toggled(GtkCellRenderer *renderer, gchar *path_str, PrefsDialog *prefs_dialog) {
+ GtkTreeIter iter;
+ GtkTreePath *path;
+
+ gboolean old_value;
+
+ path = gtk_tree_path_new_from_string(path_str);
+
+ gtk_tree_model_get_iter(GTK_TREE_MODEL(prefs_dialog->sensors_applet->sensors), &iter, path);
+ gtk_tree_model_get(GTK_TREE_MODEL(prefs_dialog->sensors_applet->sensors),
+ &iter,
+ ENABLE_COLUMN, &old_value,
+ -1);
+
+ if (old_value) {
+ sensors_applet_sensor_disabled(prefs_dialog->sensors_applet,
+ path);
+ } else {
+ sensors_applet_sensor_enabled(prefs_dialog->sensors_applet,
+ path);
+ }
+
+ gtk_tree_store_set(prefs_dialog->sensors_applet->sensors, &iter,
+ ENABLE_COLUMN, !old_value,
+ -1);
+
+ gtk_tree_path_free(path);
+}
+
+static void prefs_dialog_sensor_name_changed(GtkCellRenderer *renderer, gchar *path_str, gchar *new_text, PrefsDialog *prefs_dialog) {
+ GtkTreeIter iter;
+ GtkTreePath *path = gtk_tree_path_new_from_string(path_str);
+
+ gtk_tree_model_get_iter(GTK_TREE_MODEL(prefs_dialog->sensors_applet->sensors), &iter, path);
+
+ gtk_tree_store_set(prefs_dialog->sensors_applet->sensors, &iter, LABEL_COLUMN, new_text, -1);
+
+ sensors_applet_update_sensor(prefs_dialog->sensors_applet, path);
+ gtk_tree_path_free(path);
+}
+
+static void prefs_dialog_row_activated(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColumn *column, PrefsDialog *prefs_dialog) {
+ /* only bring up dialog this if is a sensor - ie has no
+ * children */
+ GtkTreeIter iter;
+ GtkTreeModel *model;
+
+ model = gtk_tree_view_get_model(view);
+ /* make sure can set iter first */
+ if (gtk_tree_model_get_iter(model, &iter, path) && !gtk_tree_model_iter_has_child(model, &iter)) {
+ sensor_config_dialog_create(prefs_dialog->sensors_applet);
+ }
+}
+
+
+static void prefs_dialog_sensor_up_button_clicked(GtkButton *button, PrefsDialog *prefs_dialog) {
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+ GtkTreePath *path;
+
+ if (gtk_tree_selection_get_selected(prefs_dialog->sensors_applet->selection, &model, &iter)) {
+ /* if has no prev node set up button insentive */
+ path = gtk_tree_model_get_path(model, &iter);
+ if (gtk_tree_path_prev(path)) {
+ GtkTreeIter prev_iter;
+ /* check is a valid node in out model */
+ if (gtk_tree_model_get_iter(model, &prev_iter, path)) {
+ gtk_tree_store_move_before(GTK_TREE_STORE(model),
+ &iter,
+ &prev_iter);
+ g_signal_emit_by_name(prefs_dialog->sensors_applet->selection,
+ "changed");
+
+ sensors_applet_reorder_sensors(prefs_dialog->sensors_applet);
+
+
+ }
+ }
+
+ gtk_tree_path_free(path);
+
+ }
+}
+
+static void prefs_dialog_sensor_down_button_clicked(GtkButton *button, PrefsDialog *prefs_dialog) {
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+ GtkTreeIter iter_next;
+
+ if (gtk_tree_selection_get_selected(prefs_dialog->sensors_applet->selection, &model, &iter)) {
+ iter_next = iter;
+ /* if has no next node set down button insentive */
+ if (gtk_tree_model_iter_next(model, &iter_next)) {
+ gtk_tree_store_move_after(GTK_TREE_STORE(model),
+ &iter,
+ &iter_next);
+ g_signal_emit_by_name(prefs_dialog->sensors_applet->selection,
+ "changed");
+ sensors_applet_reorder_sensors(prefs_dialog->sensors_applet);
+
+ }
+ }
+}
+
+
+
+static void prefs_dialog_sensor_config_button_clicked(GtkButton *button, PrefsDialog *prefs_dialog) {
+ sensor_config_dialog_create(prefs_dialog->sensors_applet);
+}
+
+
+/* if a sensor is selected, make config sure button is able to be
+ * clicked and also set the sensitivities properly for the up and down
+ * buttons */
+static void prefs_dialog_selection_changed(GtkTreeSelection *selection,
+ PrefsDialog *prefs_dialog) {
+ GtkTreeIter iter;
+ GtkTreePath *path;
+ GtkTreeModel *model;
+ /* if there is a selection with no children make config button
+ * sensitive */
+ if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
+ if (!gtk_tree_model_iter_has_child(model, &iter)) {
+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->sensor_config_button), TRUE);
+ } else {
+ /* otherwise make insensitive */
+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->sensor_config_button), FALSE);
+ }
+
+ /* if has no prev node set up button insentive */
+ path = gtk_tree_model_get_path(model, &iter);
+ if (gtk_tree_path_prev(path)) {
+ GtkTreeIter prev_iter;
+ /* check is a valid node in out model */
+ if (gtk_tree_model_get_iter(model, &prev_iter, path)) {
+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->sensor_up_button), TRUE);
+ } else {
+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->sensor_up_button), FALSE);
+ }
+ } else {
+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->sensor_up_button), FALSE);
+ }
+
+ gtk_tree_path_free(path);
+
+ /* if has no next node set down button insentive */
+ if (gtk_tree_model_iter_next(model, &iter)) {
+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->sensor_down_button), TRUE);
+ } else {
+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->sensor_down_button), FALSE);
+ }
+
+ } else {
+ /* otherwise make all insensitive */
+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->sensor_config_button), FALSE);
+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->sensor_up_button), FALSE);
+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->sensor_down_button), FALSE);
+
+ }
+}
+
+void prefs_dialog_open(SensorsApplet *sensors_applet) {
+ gchar *header_text;
+ PrefsDialog *prefs_dialog;
+ DisplayMode display_mode;
+
+ g_assert(sensors_applet->prefs_dialog == NULL);
+
+ /* while prefs dialog is open, stop the updating of sensors so
+ * we don't get any race conditions due to concurrent updates
+ * of the labels, values and icons linked lists etc. */
+ if (sensors_applet->timeout_id != 0) {
+ if (g_source_remove(sensors_applet->timeout_id)) {
+ sensors_applet->timeout_id = 0;
+ }
+ }
+
+ sensors_applet->prefs_dialog = g_new0(PrefsDialog, 1);
+ prefs_dialog = sensors_applet->prefs_dialog;
+
+ prefs_dialog->sensors_applet = sensors_applet;
+
+ prefs_dialog->dialog = GTK_DIALOG(gtk_dialog_new_with_buttons(_("Sensors Applet Preferences"),
+ NULL,
+ GTK_DIALOG_NO_SEPARATOR,
+ GTK_STOCK_HELP,
+ GTK_RESPONSE_HELP,
+ GTK_STOCK_CLOSE,
+ GTK_RESPONSE_CLOSE,
+ NULL));
+ g_object_set(prefs_dialog->dialog,
+ "border-width", 12,
+ "default-width", 480,
+ "default-height", 350,
+ NULL);
+
+ gtk_box_set_homogeneous(GTK_BOX(prefs_dialog->dialog->vbox), FALSE);
+
+ gtk_box_set_spacing(GTK_BOX(prefs_dialog->dialog->vbox), 5);
+
+
+ g_signal_connect(prefs_dialog->dialog,
+ "response", G_CALLBACK(prefs_dialog_response),
+ sensors_applet);
+
+ g_signal_connect_swapped(prefs_dialog->dialog,
+ "delete-event", G_CALLBACK(prefs_dialog_close),
+ sensors_applet);
+
+ g_signal_connect_swapped(prefs_dialog->dialog,
+ "destroy", G_CALLBACK(prefs_dialog_close),
+ sensors_applet);
+
+ /* if no SensorsList's have been created, this is because
+ we haven't been able to access any sensors */
+ if (sensors_applet->sensors == NULL) {
+ GtkWidget *label;
+ label = gtk_label_new(_("No sensors found!"));
+ gtk_box_pack_start_defaults(GTK_BOX(prefs_dialog->dialog->vbox), label);
+ return;
+ }
+
+
+ header_text = g_markup_printf_escaped("<b>%s</b>", _("Display"));
+ prefs_dialog->display_header = g_object_new(GTK_TYPE_LABEL,
+ "use-markup", TRUE,
+ "label", header_text,
+
+ "xalign", 0.0,
+ NULL);
+ g_free(header_text);
+
+ prefs_dialog->display_mode_combo_box = GTK_COMBO_BOX(gtk_combo_box_new_text());
+
+
+ gtk_combo_box_append_text(prefs_dialog->display_mode_combo_box, _("label with value"));
+ gtk_combo_box_append_text(prefs_dialog->display_mode_combo_box, _("icon with value"));
+ gtk_combo_box_append_text(prefs_dialog->display_mode_combo_box, _("value only"));
+ gtk_combo_box_append_text(prefs_dialog->display_mode_combo_box, _("icon only"));
+ gtk_combo_box_append_text(prefs_dialog->display_mode_combo_box, _("graph only"));
+
+
+ display_mode = panel_applet_gconf_get_int(sensors_applet->applet, DISPLAY_MODE, NULL);
+ gtk_combo_box_set_active(prefs_dialog->display_mode_combo_box, display_mode);
+
+ g_signal_connect(prefs_dialog->display_mode_combo_box,
+ "changed",
+ G_CALLBACK(prefs_dialog_display_mode_changed),
+ prefs_dialog);
+
+
+
+ /* use spaces in label to indent */
+ prefs_dialog->display_mode_label = g_object_new(GTK_TYPE_LABEL,
+ "use-underline", TRUE,
+ "label", _("_Display sensors in panel as"),
+ "mnemonic-widget", prefs_dialog->display_mode_combo_box,
+ "xalign", 0.0,
+ NULL);
+
+
+
+
+ prefs_dialog->layout_mode_combo_box = GTK_COMBO_BOX(gtk_combo_box_new_text());
+
+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->layout_mode_combo_box),
+ (display_mode != DISPLAY_ICON) &&
+ (display_mode != DISPLAY_VALUE) &&
+ (display_mode != DISPLAY_GRAPH));
+
+ gtk_combo_box_append_text(prefs_dialog->layout_mode_combo_box, _("beside labels / icons"));
+ gtk_combo_box_append_text(prefs_dialog->layout_mode_combo_box, _("below labels / icons"));
+
+ gtk_combo_box_set_active(prefs_dialog->layout_mode_combo_box, panel_applet_gconf_get_int(sensors_applet->applet, LAYOUT_MODE, NULL));
+
+ g_signal_connect(prefs_dialog->layout_mode_combo_box,
+ "changed",
+ G_CALLBACK(prefs_dialog_layout_mode_changed),
+ prefs_dialog);
+
+ prefs_dialog->layout_mode_label = g_object_new(GTK_TYPE_LABEL,
+ "use-underline", TRUE,
+ "label", _("Preferred _position of sensor values"),
+ "mnemonic-widget", prefs_dialog->layout_mode_combo_box,
+ "xalign", 0.0,
+ NULL);
+
+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->layout_mode_label),
+ (display_mode != DISPLAY_ICON) &&
+ (display_mode != DISPLAY_VALUE) &&
+ (display_mode != DISPLAY_GRAPH));
+
+ prefs_dialog->temperature_scale_combo_box = GTK_COMBO_BOX(gtk_combo_box_new_text());
+
+ gtk_combo_box_append_text(prefs_dialog->temperature_scale_combo_box, _("Kelvin"));
+ gtk_combo_box_append_text(prefs_dialog->temperature_scale_combo_box, _("Celsius"));
+ gtk_combo_box_append_text(prefs_dialog->temperature_scale_combo_box, _("Fahrenheit"));
+
+ gtk_combo_box_set_active(prefs_dialog->temperature_scale_combo_box, panel_applet_gconf_get_int(sensors_applet->applet, TEMPERATURE_SCALE, NULL));
+
+ g_signal_connect(prefs_dialog->temperature_scale_combo_box,
+ "changed",
+ G_CALLBACK(prefs_dialog_temperature_scale_changed),
+ prefs_dialog);
+
+ prefs_dialog->temperature_scale_label = g_object_new(GTK_TYPE_LABEL,
+ "use-underline", TRUE,
+ "label", _("_Temperature scale"),
+ "mnemonic-widget", prefs_dialog->temperature_scale_combo_box,
+ "xalign", 0.0,
+ NULL);
+
+ prefs_dialog->graph_size_adjust = g_object_new(GTK_TYPE_ADJUSTMENT,
+ "value", (gdouble)panel_applet_gconf_get_int(sensors_applet->applet,
+ GRAPH_SIZE,
+ NULL),
+ "lower", 1.0,
+ "upper", 100.0,
+ "step-increment", 1.0,
+ "page-increment", 10.0,
+ "page-size", 0.0,
+ NULL);
+
+ prefs_dialog->graph_size_spinbutton = g_object_new(GTK_TYPE_SPIN_BUTTON,
+ "adjustment", prefs_dialog->graph_size_adjust,
+ "climb-rate", 1.0,
+ "digits", 0,
+ "value", (gdouble)panel_applet_gconf_get_int(sensors_applet->applet,
+ GRAPH_SIZE,
+ NULL),
+ "width-chars", 4,
+ NULL);
+
+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->graph_size_spinbutton),
+ (display_mode == DISPLAY_GRAPH));
+
+ prefs_dialog->graph_size_label = g_object_new(GTK_TYPE_LABEL,
+ "use-underline", TRUE,
+ "label", _("Graph _size (pixels)"),
+ "mnemonic-widget", prefs_dialog->graph_size_spinbutton,
+ "xalign", 0.0,
+ NULL);
+
+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->graph_size_label),
+ (display_mode == DISPLAY_GRAPH));
+
+ g_signal_connect(prefs_dialog->graph_size_spinbutton, "value-changed",
+ G_CALLBACK(prefs_dialog_graph_size_changed),
+ prefs_dialog);
+
+
+ header_text = g_markup_printf_escaped("<b>%s</b>", _("Update"));
+ prefs_dialog->update_header = g_object_new(GTK_TYPE_LABEL,
+ "use-markup", TRUE,
+ "label", header_text,
+
+ "xalign", 0.0,
+ NULL);
+ g_free(header_text);
+
+
+ prefs_dialog->timeout_adjust = g_object_new(GTK_TYPE_ADJUSTMENT,
+ "value", 2.0,
+ "lower", 1.5,
+ "upper", 10.0,
+ "step-increment", 0.5,
+ "page-increment", 1.0,
+ "page-size", 0.0,
+ NULL);
+
+ prefs_dialog->timeout_spinbutton = g_object_new(GTK_TYPE_SPIN_BUTTON,
+ "adjustment", prefs_dialog->timeout_adjust,
+ "climb-rate", 0.5,
+ "digits", 1,
+ "value", (gdouble) panel_applet_gconf_get_int(sensors_applet->applet, TIMEOUT, NULL) / 1000.0,
+ "width-chars", 4,
+ NULL);
+
+
+ prefs_dialog->timeout_label = g_object_new(GTK_TYPE_LABEL,
+ "use-underline", TRUE,
+ "label", _("Update _interval (secs)"),
+ "mnemonic-widget", prefs_dialog->timeout_spinbutton,
+ "xalign", 0.0,
+ NULL);
+
+ g_signal_connect(prefs_dialog->timeout_spinbutton, "value-changed",
+ G_CALLBACK(prefs_dialog_timeout_changed),
+ prefs_dialog);
+
+#ifdef HAVE_LIBNOTIFY
+ header_text = g_markup_printf_escaped("<b>%s</b>", _("Notifications"));
+ prefs_dialog->notifications_header = g_object_new(GTK_TYPE_LABEL,
+ "use-markup", TRUE,
+ "label", header_text,
+
+ "xalign", 0.0,
+ NULL);
+ g_free(header_text);
+
+ prefs_dialog->display_notifications = g_object_new(GTK_TYPE_CHECK_BUTTON,
+ "use-underline", TRUE,
+ "label", _("Display _notifications"),
+ NULL);
+ gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(prefs_dialog->display_notifications),
+ panel_applet_gconf_get_bool(sensors_applet->applet,
+ DISPLAY_NOTIFICATIONS,
+ NULL));
+ g_signal_connect(prefs_dialog->display_notifications,
+ "toggled",
+ G_CALLBACK(prefs_dialog_display_notifications_toggled),
+ prefs_dialog);
+#endif
+
+ /* SIZE AND LAYOUT */
+ /* keep all widgets same size */
+ prefs_dialog->size_group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
+
+ gtk_size_group_add_widget(prefs_dialog->size_group,
+ GTK_WIDGET(prefs_dialog->display_mode_combo_box));
+
+ gtk_size_group_add_widget(prefs_dialog->size_group,
+ GTK_WIDGET(prefs_dialog->layout_mode_combo_box));
+
+ gtk_size_group_add_widget(prefs_dialog->size_group,
+ GTK_WIDGET(prefs_dialog->temperature_scale_combo_box));
+
+ gtk_size_group_add_widget(prefs_dialog->size_group,
+ GTK_WIDGET(prefs_dialog->timeout_spinbutton));
+
+ g_object_unref(prefs_dialog->size_group);
+
+ prefs_dialog->globals_table = g_object_new(GTK_TYPE_TABLE,
+ "homogeneous", FALSE,
+ "n-columns", 3,
+#ifdef HAVE_LIBNOTIFY
+ "n-rows", 9,
+#else
+ "n-rows", 7,
+#endif
+ "row-spacing", 6,
+ "column-spacing", 12,
+ NULL);
+
+
+ gtk_table_attach(prefs_dialog->globals_table,
+ GTK_WIDGET(prefs_dialog->display_header),
+ 0, 2,
+ 0, 1,
+ GTK_FILL,
+ GTK_FILL,
+ 0,
+ 0);
+
+ gtk_table_attach(prefs_dialog->globals_table,
+ GTK_WIDGET(prefs_dialog->display_mode_label),
+ 1, 2,
+ 1, 2,
+ GTK_FILL,
+ GTK_FILL,
+ 0,
+ 0);
+
+ gtk_table_attach(prefs_dialog->globals_table,
+ GTK_WIDGET(prefs_dialog->display_mode_combo_box),
+ 2, 3,
+ 1, 2,
+ GTK_FILL,
+ GTK_FILL,
+ 0,
+ 0);
+
+
+ gtk_table_attach(prefs_dialog->globals_table,
+ GTK_WIDGET(prefs_dialog->layout_mode_label),
+ 1, 2,
+ 2, 3,
+ GTK_FILL,
+ GTK_FILL,
+ 0,
+ 0);
+ gtk_table_attach(prefs_dialog->globals_table,
+ GTK_WIDGET(prefs_dialog->layout_mode_combo_box),
+ 2, 3,
+ 2, 3,
+ GTK_FILL,
+ GTK_FILL,
+ 0,
+ 0);
+
+
+
+ gtk_table_attach(prefs_dialog->globals_table,
+ GTK_WIDGET(prefs_dialog->graph_size_label),
+ 1, 2,
+ 3, 4,
+ GTK_FILL,
+ GTK_FILL,
+ 0,
+ 0);
+
+ gtk_table_attach(prefs_dialog->globals_table,
+ GTK_WIDGET(prefs_dialog->graph_size_spinbutton),
+ 2, 3,
+ 3, 4,
+ GTK_FILL,
+ GTK_FILL,
+ 0,
+ 0);
+
+ gtk_table_attach(prefs_dialog->globals_table,
+ GTK_WIDGET(prefs_dialog->temperature_scale_label),
+ 1, 2,
+ 4, 5,
+ GTK_FILL,
+ GTK_FILL,
+ 0,
+ 0);
+ gtk_table_attach(prefs_dialog->globals_table,
+ GTK_WIDGET(prefs_dialog->temperature_scale_combo_box),
+ 2, 3,
+ 4, 5,
+ GTK_FILL,
+ GTK_FILL,
+ 0,
+ 0);
+
+ gtk_table_attach(prefs_dialog->globals_table,
+ GTK_WIDGET(prefs_dialog->update_header),
+ 0, 2,
+ 5, 6,
+ GTK_FILL,
+ GTK_FILL,
+ 0,
+ 0);
+
+ gtk_table_attach(prefs_dialog->globals_table,
+ GTK_WIDGET(prefs_dialog->timeout_label),
+ 1, 2,
+ 6, 7,
+ GTK_FILL,
+ GTK_FILL,
+ 0,
+ 0);
+
+ gtk_table_attach(prefs_dialog->globals_table,
+ GTK_WIDGET(prefs_dialog->timeout_spinbutton),
+ 2, 3,
+ 6, 7,
+ GTK_FILL,
+ GTK_FILL,
+ 0,
+ 0);
+
+
+#ifdef HAVE_LIBNOTIFY
+ gtk_table_attach(prefs_dialog->globals_table,
+ GTK_WIDGET(prefs_dialog->notifications_header),
+ 0, 2,
+ 7, 8,
+ GTK_FILL,
+ GTK_FILL,
+ 0,
+ 0);
+
+ gtk_table_attach(prefs_dialog->globals_table,
+ GTK_WIDGET(prefs_dialog->display_notifications),
+ 1, 2,
+ 8, 9,
+ GTK_FILL,
+ GTK_FILL,
+ 0,
+ 0);
+#endif
+
+
+ prefs_dialog->view = g_object_new(GTK_TYPE_TREE_VIEW,
+ "model", GTK_TREE_MODEL(sensors_applet->sensors),
+ "rules-hint", TRUE,
+ "reorderable", FALSE,
+ "enable-search", TRUE,
+ "search-column", LABEL_COLUMN,
+ NULL);
+
+ /* get double clicks on rows - do same as configure sensor
+ * button clicks */
+ g_signal_connect(prefs_dialog->view, "row-activated",
+ G_CALLBACK(prefs_dialog_row_activated),
+ prefs_dialog);
+
+ prefs_dialog->id_renderer = gtk_cell_renderer_text_new();
+ prefs_dialog->label_renderer = gtk_cell_renderer_text_new();
+ g_object_set(prefs_dialog->label_renderer,
+ "editable", TRUE,
+ NULL);
+
+ g_signal_connect(prefs_dialog->label_renderer, "edited",
+ G_CALLBACK(prefs_dialog_sensor_name_changed),
+ prefs_dialog);
+
+ prefs_dialog->enable_renderer = gtk_cell_renderer_toggle_new();
+ g_signal_connect(prefs_dialog->enable_renderer, "toggled",
+ G_CALLBACK(prefs_dialog_sensor_toggled),
+ prefs_dialog);
+ prefs_dialog->icon_renderer = gtk_cell_renderer_pixbuf_new();
+
+ prefs_dialog->id_column = gtk_tree_view_column_new_with_attributes(_("Sensor"),
+ prefs_dialog->id_renderer,
+ "text", ID_COLUMN,
+ NULL);
+
+ gtk_tree_view_column_set_min_width(prefs_dialog->id_column, 90);
+
+ prefs_dialog->label_column = gtk_tree_view_column_new_with_attributes(_("Label"),
+ prefs_dialog->label_renderer,
+ "text", LABEL_COLUMN,
+ "visible", VISIBLE_COLUMN,
+ NULL);
+
+ gtk_tree_view_column_set_min_width(prefs_dialog->label_column, 100);
+
+ /* create the tooltip */
+ gtk_widget_set_tooltip_text(GTK_WIDGET(prefs_dialog->view),
+ _("Labels can be edited directly by clicking on them."));
+ prefs_dialog->enable_column = gtk_tree_view_column_new_with_attributes(_("Enabled"),
+ prefs_dialog->enable_renderer,
+ "active", ENABLE_COLUMN,
+ "visible", VISIBLE_COLUMN,
+ NULL);
+
+ prefs_dialog->icon_column = gtk_tree_view_column_new_with_attributes(_("Icon"),
+ prefs_dialog->icon_renderer,
+ "pixbuf", ICON_PIXBUF_COLUMN,
+ "visible", VISIBLE_COLUMN,
+ NULL);
+ gtk_tree_view_append_column(prefs_dialog->view,
+ prefs_dialog->id_column);
+ gtk_tree_view_append_column(prefs_dialog->view,
+ prefs_dialog->icon_column);
+ gtk_tree_view_append_column(prefs_dialog->view,
+ prefs_dialog->label_column);
+ gtk_tree_view_append_column(prefs_dialog->view,
+ prefs_dialog->enable_column);
+
+ gtk_tree_view_columns_autosize(prefs_dialog->view);
+
+ prefs_dialog->scrolled_window = g_object_new(GTK_TYPE_SCROLLED_WINDOW,
+ "hadjustment", NULL,
+ "height-request", 200,
+ "hscrollbar-policy", GTK_POLICY_AUTOMATIC,
+ "vadjustment",NULL,
+ "vscrollbar-policy", GTK_POLICY_AUTOMATIC,
+ NULL);
+
+ gtk_container_add(GTK_CONTAINER(prefs_dialog->scrolled_window), GTK_WIDGET(prefs_dialog->view));
+
+ /* GtkTree Selection */
+ sensors_applet->selection = gtk_tree_view_get_selection(prefs_dialog->view);
+ /* allow user to only select one row at a time at most */
+ gtk_tree_selection_set_mode(sensors_applet->selection, GTK_SELECTION_SINGLE);
+ /* when selection is changed, make sure sensor_config button is
+ activated */
+
+ /* Create buttons for user to interact with sensors tree */
+ prefs_dialog->sensor_up_button = GTK_BUTTON(gtk_button_new_from_stock(GTK_STOCK_GO_UP));
+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->sensor_up_button), FALSE);
+
+ g_signal_connect(prefs_dialog->sensor_up_button, "clicked",
+ G_CALLBACK(prefs_dialog_sensor_up_button_clicked),
+ prefs_dialog);
+
+ prefs_dialog->sensor_down_button = GTK_BUTTON(gtk_button_new_from_stock(GTK_STOCK_GO_DOWN));
+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->sensor_down_button), FALSE);
+
+ g_signal_connect(prefs_dialog->sensor_down_button, "clicked",
+ G_CALLBACK(prefs_dialog_sensor_down_button_clicked),
+ prefs_dialog);
+
+
+ prefs_dialog->buttons_box = GTK_VBUTTON_BOX(gtk_vbutton_box_new());
+
+ gtk_button_box_set_layout(GTK_BUTTON_BOX(prefs_dialog->buttons_box),
+ GTK_BUTTONBOX_SPREAD);
+
+ gtk_box_pack_start(GTK_BOX(prefs_dialog->buttons_box), GTK_WIDGET(prefs_dialog->sensor_up_button), FALSE, FALSE, 0);
+
+ gtk_box_pack_start(GTK_BOX(prefs_dialog->buttons_box), GTK_WIDGET(prefs_dialog->sensor_down_button), FALSE, FALSE, 0);
+
+ prefs_dialog->sensors_hbox = g_object_new(GTK_TYPE_HBOX,
+ "border-width", 5,
+ "homogeneous", FALSE,
+ "spacing", 5,
+ NULL);
+
+ gtk_box_pack_start(prefs_dialog->sensors_hbox,
+ GTK_WIDGET(prefs_dialog->scrolled_window),
+ TRUE, TRUE, 0); /* make sure window takes
+ * up most of room */
+
+ gtk_box_pack_start(prefs_dialog->sensors_hbox,
+ GTK_WIDGET(prefs_dialog->buttons_box),
+ FALSE, FALSE, 0);
+
+
+ /* Sensor Config button */
+ /* initially make button insensitive until user selects a row
+ from the sensors tree */
+ prefs_dialog->sensor_config_button = GTK_BUTTON(gtk_button_new_from_stock(GTK_STOCK_PROPERTIES));
+ g_object_set(prefs_dialog->sensor_config_button,
+ "sensitive", FALSE,
+ NULL);
+
+
+ g_signal_connect(sensors_applet->selection,
+ "changed",
+ G_CALLBACK(prefs_dialog_selection_changed),
+ prefs_dialog);
+
+ /* pass selection to signal handler so we can give user a
+ sensors_applet->prefs_dialog with the selected rows alarm
+ value and enable */
+ g_signal_connect(prefs_dialog->sensor_config_button, "clicked",
+ G_CALLBACK(prefs_dialog_sensor_config_button_clicked),
+ prefs_dialog);
+
+ prefs_dialog->sensor_config_hbox = g_object_new(GTK_TYPE_HBOX,
+ "border-width", 5,
+ "homogeneous", FALSE,
+ "spacing", 0,
+ NULL);
+ gtk_box_pack_end(prefs_dialog->sensor_config_hbox,
+ GTK_WIDGET(prefs_dialog->sensor_config_button),
+ FALSE, FALSE, 0);
+
+ /* pack sensors_vbox */
+ prefs_dialog->sensors_vbox = g_object_new(GTK_TYPE_VBOX,
+ "border-width", 5,
+ "homogeneous", FALSE,
+ "spacing", 0,
+ NULL);
+
+ gtk_box_pack_start(prefs_dialog->sensors_vbox,
+ GTK_WIDGET(prefs_dialog->sensors_hbox),
+ TRUE, TRUE, 0);
+ gtk_box_pack_start(prefs_dialog->sensors_vbox,
+ GTK_WIDGET(prefs_dialog->sensor_config_hbox),
+ FALSE, FALSE, 0);
+
+ prefs_dialog->globals_alignment = g_object_new(GTK_TYPE_ALIGNMENT,
+ "xalign", 0.5,
+ "yalign", 0.0,
+ "top-padding", 12,
+ "left-padding", 12,
+ "bottom-padding", 12,
+ "right-padding", 12,
+ NULL);
+ gtk_container_add(GTK_CONTAINER(prefs_dialog->globals_alignment),
+ GTK_WIDGET(prefs_dialog->globals_table));
+
+ prefs_dialog->notebook = g_object_new(GTK_TYPE_NOTEBOOK,
+ NULL);
+
+ gtk_notebook_append_page(prefs_dialog->notebook,
+ GTK_WIDGET(prefs_dialog->globals_alignment),
+ gtk_label_new(_("General Options")));
+
+ gtk_notebook_append_page(prefs_dialog->notebook,
+ GTK_WIDGET(prefs_dialog->sensors_vbox),
+ gtk_label_new(_("Sensors")));
+
+ /* pack notebook into prefs_dialog */
+ gtk_box_pack_start_defaults(GTK_BOX(prefs_dialog->dialog->vbox),
+ GTK_WIDGET(prefs_dialog->notebook));
+
+
+ gtk_widget_show_all(GTK_WIDGET(prefs_dialog->dialog));
+}