/* * Copyright (C) 2005-2009 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ #ifdef HAVE_CONFIG_H #include "config.h" #endif /* HAVE_CONFIG_H */ #include #include #include "sensors-applet-settings.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 gsettings */ void prefs_dialog_close(SensorsApplet *sensors_applet) { if (sensors_applet->sensors != NULL) { sensors_applet_settings_save_sensors(sensors_applet); } 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(g_settings_get_int (sensors_applet->settings, TIMEOUT) / 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("help:mate-sensors-applet/%s", ((current_page == 0) ? "sensors-applet-general-options" : ((current_page == 1) ? "sensors-applet-sensors" : NULL))); #if GTK_CHECK_VERSION (3, 22, 0) gtk_show_uri_on_window(NULL, uri, gtk_get_current_event_time(), &error); #else gtk_show_uri(NULL, uri, gtk_get_current_event_time(), &error); #endif 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); g_settings_set_int (prefs_dialog->sensors_applet->settings, TIMEOUT, value); } 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)); g_settings_set_int (prefs_dialog->sensors_applet->settings, DISPLAY_MODE, gtk_combo_box_get_active(display_mode_combo_box)); sensors_applet_display_layout_changed(prefs_dialog->sensors_applet); } static void prefs_dialog_layout_mode_changed(GtkComboBox *layout_mode_combo_box, PrefsDialog *prefs_dialog) { g_settings_set_int (prefs_dialog->sensors_applet->settings, LAYOUT_MODE, gtk_combo_box_get_active(layout_mode_combo_box)); 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) g_settings_get_int (prefs_dialog->sensors_applet->settings, TEMPERATURE_SCALE); scales[NEW_TEMP_SCALE] = (TemperatureScale)gtk_combo_box_get_active(temperature_scale_combo_box); g_settings_set_int (prefs_dialog->sensors_applet->settings, TEMPERATURE_SCALE, scales[NEW_TEMP_SCALE]); /* 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); } // hide/show units static void prefs_dialog_show_units_toggled (GtkCheckButton *show_units, PrefsDialog *prefs_dialog) { gboolean state; state = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (show_units)); g_settings_set_boolean (prefs_dialog->sensors_applet->settings, HIDE_UNITS, !state); 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)); g_settings_set_boolean(prefs_dialog->sensors_applet->settings, DISPLAY_NOTIFICATIONS, notify); 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)); g_settings_set_int(prefs_dialog->sensors_applet->settings, GRAPH_SIZE, value); /* 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; GtkWidget *content_area; 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, 0, GTK_STOCK_HELP, GTK_RESPONSE_HELP, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL)); gtk_window_set_icon_name(GTK_WINDOW(prefs_dialog->dialog), "mate-sensors-applet"); g_object_set(prefs_dialog->dialog, "border-width", 12, "default-width", 480, "default-height", 350, NULL); content_area = gtk_dialog_get_content_area (prefs_dialog->dialog); gtk_box_set_homogeneous(GTK_BOX(content_area), FALSE); gtk_box_set_spacing(GTK_BOX(content_area), 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; GtkWidget *content_area; label = gtk_label_new(_("No sensors found!")); content_area = gtk_dialog_get_content_area (prefs_dialog->dialog); gtk_box_pack_start (GTK_BOX(content_area), label, FALSE, FALSE, 0); return; } header_text = g_markup_printf_escaped("%s", _("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_TEXT(gtk_combo_box_text_new()); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(prefs_dialog->display_mode_combo_box), _("label with value")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(prefs_dialog->display_mode_combo_box), _("icon with value")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(prefs_dialog->display_mode_combo_box), _("value only")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(prefs_dialog->display_mode_combo_box), _("icon only")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(prefs_dialog->display_mode_combo_box), _("graph only")); display_mode = g_settings_get_int(sensors_applet->settings, DISPLAY_MODE); gtk_combo_box_set_active(GTK_COMBO_BOX(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_TEXT(gtk_combo_box_text_new()); 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_text_append_text(prefs_dialog->layout_mode_combo_box, _("beside labels / icons")); gtk_combo_box_text_append_text(prefs_dialog->layout_mode_combo_box, _("below labels / icons")); gtk_combo_box_set_active( GTK_COMBO_BOX(prefs_dialog->layout_mode_combo_box), g_settings_get_int(sensors_applet->settings, LAYOUT_MODE)); 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_TEXT(gtk_combo_box_text_new()); gtk_combo_box_text_append_text(prefs_dialog->temperature_scale_combo_box, _("Kelvin")); gtk_combo_box_text_append_text(prefs_dialog->temperature_scale_combo_box, _("Celsius")); gtk_combo_box_text_append_text(prefs_dialog->temperature_scale_combo_box, _("Fahrenheit")); gtk_combo_box_set_active( GTK_COMBO_BOX(prefs_dialog->temperature_scale_combo_box), g_settings_get_int(sensors_applet->settings, TEMPERATURE_SCALE)); 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)g_settings_get_int(sensors_applet->settings, GRAPH_SIZE), "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)g_settings_get_int(sensors_applet->settings, GRAPH_SIZE), "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); // hide/show units prefs_dialog->show_units = gtk_check_button_new_with_label (_("Show _units")); gtk_button_set_use_underline (GTK_BUTTON (prefs_dialog->show_units), TRUE); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (prefs_dialog->show_units), !g_settings_get_boolean (sensors_applet->settings, HIDE_UNITS)); g_signal_connect (prefs_dialog->show_units, "toggled", G_CALLBACK (prefs_dialog_show_units_toggled), prefs_dialog); header_text = g_markup_printf_escaped("%s", _("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) g_settings_get_int(sensors_applet->settings, TIMEOUT) / 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("%s", _("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_active(GTK_TOGGLE_BUTTON(prefs_dialog->display_notifications), g_settings_get_boolean(sensors_applet->settings, DISPLAY_NOTIFICATIONS)); 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_grid = g_object_new(GTK_TYPE_GRID, "row-homogeneous", FALSE, "column-homogeneous", FALSE, "row-spacing", 6, "column-spacing", 12, NULL); gtk_grid_attach(prefs_dialog->globals_grid, GTK_WIDGET(prefs_dialog->display_header), 0, 0, 2, 1); gtk_grid_attach(prefs_dialog->globals_grid, GTK_WIDGET(prefs_dialog->display_mode_label), 1, 1, 1, 1); gtk_grid_attach(prefs_dialog->globals_grid, GTK_WIDGET(prefs_dialog->display_mode_combo_box), 2, 1, 1, 1); gtk_grid_attach(prefs_dialog->globals_grid, GTK_WIDGET(prefs_dialog->layout_mode_label), 1, 2, 1, 1); gtk_grid_attach(prefs_dialog->globals_grid, GTK_WIDGET(prefs_dialog->layout_mode_combo_box), 2, 2, 1, 1); gtk_grid_attach(prefs_dialog->globals_grid, GTK_WIDGET(prefs_dialog->graph_size_label), 1, 3, 1, 1); gtk_grid_attach(prefs_dialog->globals_grid, GTK_WIDGET(prefs_dialog->graph_size_spinbutton), 2, 3, 1, 1); gtk_grid_attach(prefs_dialog->globals_grid, GTK_WIDGET(prefs_dialog->temperature_scale_label), 1, 4, 1, 1); gtk_grid_attach(prefs_dialog->globals_grid, GTK_WIDGET(prefs_dialog->temperature_scale_combo_box), 2, 4, 1, 1); gtk_grid_attach(prefs_dialog->globals_grid, GTK_WIDGET(prefs_dialog->show_units), 1, 5, 1, 1); gtk_grid_attach(prefs_dialog->globals_grid, GTK_WIDGET(prefs_dialog->update_header), 0, 6, 2, 1); gtk_grid_attach(prefs_dialog->globals_grid, GTK_WIDGET(prefs_dialog->timeout_label), 1, 7, 1, 1); gtk_grid_attach(prefs_dialog->globals_grid, GTK_WIDGET(prefs_dialog->timeout_spinbutton), 2, 7, 1, 1); #ifdef HAVE_LIBNOTIFY gtk_grid_attach(prefs_dialog->globals_grid, GTK_WIDGET(prefs_dialog->notifications_header), 0, 8, 2, 1); gtk_grid_attach(prefs_dialog->globals_grid, GTK_WIDGET(prefs_dialog->display_notifications), 1, 9, 1, 1); #endif gtk_widget_set_valign(GTK_WIDGET(prefs_dialog->globals_grid), GTK_ALIGN_START); gtk_widget_set_margin_start(GTK_WIDGET(prefs_dialog->globals_grid), 12); gtk_widget_set_margin_end(GTK_WIDGET(prefs_dialog->globals_grid), 12); gtk_widget_set_margin_top(GTK_WIDGET(prefs_dialog->globals_grid), 12); gtk_widget_set_margin_bottom(GTK_WIDGET(prefs_dialog->globals_grid), 12); 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_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(prefs_dialog->scrolled_window), GTK_SHADOW_IN); 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_BUTTON_BOX(gtk_button_box_new(GTK_ORIENTATION_VERTICAL)); 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_BOX, "orientation", GTK_ORIENTATION_HORIZONTAL, "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_BOX, "orientation", GTK_ORIENTATION_HORIZONTAL, "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_BOX, "orientation", GTK_ORIENTATION_VERTICAL, "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->notebook = g_object_new(GTK_TYPE_NOTEBOOK, NULL); gtk_notebook_append_page(prefs_dialog->notebook, GTK_WIDGET(prefs_dialog->globals_grid), 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 */ content_area = gtk_dialog_get_content_area (prefs_dialog->dialog); gtk_box_pack_start (GTK_BOX(content_area), GTK_WIDGET(prefs_dialog->notebook), TRUE, TRUE, 0); gtk_widget_show_all(GTK_WIDGET(prefs_dialog->dialog)); }