Avoid multiple sensor preferences dialog at the same time.

diff --git a/src/cfg.c b/src/cfg.c
index c493a9e..075989a 100644 (file)
--- a/src/cfg.c
+++ b/src/cfg.c
@@ -663,7 +663,7 @@ void config_set_sensor_color(const char *sid, const GdkRGBA *color)
        g_free(str);
 }
 
-static char *next_default_color(void)
+static const char *next_default_color(void)
 {
        /* copied from the default colors of the gtk color color
         * chooser. */
@@ -697,7 +697,7 @@ static char *next_default_color(void)
                "#babdb6"
        };
        static int next_idx;
-       char *c;
+       const char *c;
 
        c = default_colors[next_idx % 27];
 
@@ -883,3 +883,8 @@ void config_set_udisks2_enable(bool b)
 {
        set_bool(KEY_PROVIDER_UDISKS2_ENABLED, b);
 }
+
+int config_get_sensor_unit(void)
+{
+       return get_int(KEY_INTERFACE_TEMPERATURE_UNIT);
+}

diff --git a/src/cfg.h b/src/cfg.h
index 36d9613..2aa5a3e 100644 (file)
--- a/src/cfg.h
+++ b/src/cfg.h
@@ -146,6 +146,8 @@ void config_set_nvctrl_enable(bool);
 bool config_is_atiadlsdk_enabled(void);
 void config_set_atiadlsdk_enable(bool);
 
+int config_get_sensor_unit(void);
+
 /*
  * Returns the user directory containing psensor data (configuration
  * and log).

diff --git a/src/glade/sensor-edit.glade b/src/glade/sensor-edit.glade
index 24d80f3..3430082 100644 (file)
--- a/src/glade/sensor-edit.glade
+++ b/src/glade/sensor-edit.glade
@@ -87,7 +87,9 @@
                     <property name="reorderable">True</property>
                     <property name="search_column">1</property>
                     <child internal-child="selection">
-                      <object class="GtkTreeSelection" id="treeview-selection"/>
+                      <object class="GtkTreeSelection" id="treeview-selection">
+                        <signal name="changed" handler="ui_sensorpref_tree_selection_changed_cb" swapped="no"/>
+                      </object>
                     </child>
                     <child>
                       <object class="GtkTreeViewColumn" id="sensor_name_col">

diff --git a/src/lib/pmutex.c b/src/lib/pmutex.c
index ec529bd..f374d12 100644 (file)
--- a/src/lib/pmutex.c
+++ b/src/lib/pmutex.c
@@ -21,6 +21,7 @@
 
 #include <plog.h>
 #include <pmutex.h>
+#include <string.h>
 
 int pmutex_lock(pthread_mutex_t *m)
 {
@@ -29,7 +30,7 @@ int pmutex_lock(pthread_mutex_t *m)
        ret = pthread_mutex_lock(m);
 
        if (ret)
-               log_err("pmutex_lock: %p %d", m, ret);
+               log_err("pmutex_lock: %p %d %s", m, ret, strerror(ret));
 
        return ret;
 }

diff --git a/src/ui.c b/src/ui.c
index ddf7fd4..fc5f5c3 100644 (file)
--- a/src/ui.c
+++ b/src/ui.c
@@ -349,11 +349,11 @@ static int cmp_sensors(const void *p1, const void *p2)
        return pos1 - pos2;
 }
 
-struct psensor **ui_get_sensors_ordered_by_position(const struct ui_psensor *ui)
+struct psensor **ui_get_sensors_ordered_by_position(struct psensor **sensors)
 {
        struct psensor **result;
 
-       result = psensor_list_copy(ui->sensors);
+       result = psensor_list_copy(sensors);
        qsort(result,
              psensor_list_size(result),
              sizeof(struct psensor *),

diff --git a/src/ui.h b/src/ui.h
index 8232faf..453cdb0 100644 (file)
--- a/src/ui.h
+++ b/src/ui.h
@@ -98,5 +98,5 @@ void ui_cb_about(GtkMenuItem *mi, gpointer data);
 void ui_cb_menu_quit(GtkMenuItem *mi, gpointer data);
 void ui_cb_sensor_preferences(GtkMenuItem *mi, gpointer data);
 
-struct psensor **ui_get_sensors_ordered_by_position(const struct ui_psensor *);
+struct psensor **ui_get_sensors_ordered_by_position(struct psensor **);
 #endif

diff --git a/src/ui_appindicator.c b/src/ui_appindicator.c
index 25ec3ab..2776882 100644 (file)
--- a/src/ui_appindicator.c
+++ b/src/ui_appindicator.c
@@ -98,7 +98,7 @@ create_sensor_menu_items(const struct ui_psensor *ui, GtkMenu *menu)
 
        celsius  = ui->config->temperature_unit == CELSIUS;
 
-       sorted_sensors = ui_get_sensors_ordered_by_position(ui);
+       sorted_sensors = ui_get_sensors_ordered_by_position(ui->sensors);
        n = psensor_list_size(sorted_sensors);
        menu_items = malloc((n + 1) * sizeof(GtkWidget *));
 
@@ -166,7 +166,7 @@ static void update_label(struct ui_psensor *ui)
        char *label, *str, *tmp, *guide;
        struct psensor **p;
 
-       p =  ui_get_sensors_ordered_by_position(ui);
+       p =  ui_get_sensors_ordered_by_position(ui->sensors);
        label = NULL;
        guide = NULL;
        while (*p) {

diff --git a/src/ui_sensorlist.c b/src/ui_sensorlist.c
index 52df001..cc00d79 100644 (file)
--- a/src/ui_sensorlist.c
+++ b/src/ui_sensorlist.c
@@ -63,7 +63,7 @@ static void populate(struct ui_psensor *ui)
        struct psensor **ordered_sensors, **s_cur, *s;
        unsigned int enabled;
 
-       ordered_sensors = ui_get_sensors_ordered_by_position(ui);
+       ordered_sensors = ui_get_sensors_ordered_by_position(ui->sensors);
        store = ui->sensors_store;
 
        gtk_list_store_clear(store);

diff --git a/src/ui_sensorpref.c b/src/ui_sensorpref.c
index 05bf8c7..b6bcb1e 100644 (file)
--- a/src/ui_sensorpref.c
+++ b/src/ui_sensorpref.c
@@ -33,22 +33,37 @@ enum {
        COL_SENSOR_PREF
 };
 
-struct cb_data {
-       struct ui_psensor *ui;
-       GtkBuilder *builder;
-};
-
-static struct psensor *get_selected_sensor(GtkBuilder *builder)
+static GtkTreeView *w_sensors_list;
+static GtkDialog *w_dialog;
+static GtkLabel *w_sensor_id;
+static GtkLabel *w_sensor_type;
+static GtkLabel *w_sensor_chipname;
+static GtkLabel *w_sensor_low_threshold_unit;
+static GtkLabel *w_sensor_high_threshold_unit;
+static GtkEntry *w_sensor_name;
+static GtkToggleButton *w_sensor_draw;
+static GtkToggleButton *w_sensor_display;
+static GtkToggleButton *w_sensor_alarm;
+static GtkToggleButton *w_appindicator_enabled;
+static GtkToggleButton *w_appindicator_label_enabled;
+static GtkColorButton *w_sensor_color;
+static GtkSpinButton *w_sensor_high_threshold;
+static GtkSpinButton *w_sensor_low_threshold;
+static GtkListStore *store;
+
+
+/* 'true' when the notifications of field changes are due to the change
+ * of the selected sensor. */
+static bool ignore_changes;
+
+static struct psensor *get_selected_sensor(void)
 {
        GtkTreeModel *model;
        GtkTreeIter iter;
        struct psensor *s;
        GtkTreeSelection *selection;
-       GtkTreeView *tree;
 
-       tree = GTK_TREE_VIEW(gtk_builder_get_object(builder, "sensors_list"));
-
-       selection = gtk_tree_view_get_selection(tree);
+       selection = gtk_tree_view_get_selection(w_sensors_list);
 
        s = NULL;
        if (gtk_tree_selection_get_selected(selection, &model, &iter))
@@ -68,251 +83,226 @@ static void apply_config(struct ui_psensor *ui)
 void ui_sensorpref_name_changed_cb(GtkEntry *entry, gpointer data)
 {
        struct psensor *s;
-       struct cb_data *cbdata;
 
        const gchar *str;
 
-       cbdata = (struct cb_data *)data;
+       if (ignore_changes)
+               return;
 
-       s = get_selected_sensor(cbdata->builder);
+       s = get_selected_sensor();
+
+       if (!s)
+               return;
 
        str = gtk_entry_get_text(entry);
 
-       if (s) {
-               if (strcmp(str, s->name)) {
-                       free(s->name);
-                       s->name = strdup(str);
-                       config_set_sensor_name(s->id, str);
+       if (strcmp(str, s->name)) {
+               free(s->name);
+               s->name = strdup(str);
+               config_set_sensor_name(s->id, str);
 
-                       apply_config(cbdata->ui);
-               }
+               apply_config((struct ui_psensor *)data);
        }
 }
 
 void ui_sensorpref_draw_toggled_cb(GtkToggleButton *btn, gpointer data)
 {
        gboolean active;
-       struct cb_data *cbdata;
        struct psensor *s;
 
-       cbdata = (struct cb_data *)data;
+       if (ignore_changes)
+               return;
 
-       s = get_selected_sensor(cbdata->builder);
-       if (s) {
-               active = gtk_toggle_button_get_active(btn);
-               config_set_sensor_graph_enabled(s->id, active);
+       s = get_selected_sensor();
 
-               apply_config(cbdata->ui);
-       }
+       if (!s)
+               return;
+
+       active = gtk_toggle_button_get_active(btn);
+       config_set_sensor_graph_enabled(s->id, active);
+
+       apply_config((struct ui_psensor *)data);
 }
 
 void ui_sensorpref_display_toggled_cb(GtkToggleButton *btn, gpointer data)
 {
        gboolean active;
-       struct cb_data *cbdata;
        struct psensor *s;
 
-       cbdata = (struct cb_data *)data;
+       if (ignore_changes)
+               return;
 
-       s = get_selected_sensor(cbdata->builder);
+       s = get_selected_sensor();
 
-       if (s) {
-               active = gtk_toggle_button_get_active(btn);
-               config_set_sensor_enabled(s->id, active);
+       if (!s)
+               return;
 
-               apply_config(cbdata->ui);
-       }
+       active = gtk_toggle_button_get_active(btn);
+       config_set_sensor_enabled(s->id, active);
 
+       apply_config((struct ui_psensor *)data);
 }
 
 void ui_sensorpref_alarm_toggled_cb(GtkToggleButton *btn, gpointer data)
 {
        gboolean active;
-       struct cb_data *cbdata;
        struct psensor *s;
 
-       cbdata = (struct cb_data *)data;
+       if (ignore_changes)
+               return;
 
-       s = get_selected_sensor(cbdata->builder);
+       s = get_selected_sensor();
 
-       if (s) {
-               active = gtk_toggle_button_get_active(btn);
-               config_set_sensor_alarm_enabled(s->id, active);
+       if (!s)
+               return;
 
-               apply_config(cbdata->ui);
-       }
+       active = gtk_toggle_button_get_active(btn);
+       config_set_sensor_alarm_enabled(s->id, active);
+
+       apply_config((struct ui_psensor *)data);
 }
 
 void
 ui_sensorpref_appindicator_menu_toggled_cb(GtkToggleButton *btn, gpointer data)
 {
        gboolean active;
-       struct cb_data *cbdata;
        struct psensor *s;
 
-       cbdata = (struct cb_data *)data;
+       if (ignore_changes)
+               return;
 
-       s = get_selected_sensor(cbdata->builder);
+       s = get_selected_sensor();
 
-       if (s) {
-               active = gtk_toggle_button_get_active(btn);
-               config_set_appindicator_enabled(s->id, active);
+       if (!s)
+               return;
 
-               apply_config(cbdata->ui);
-       }
+       active = gtk_toggle_button_get_active(btn);
+       config_set_appindicator_enabled(s->id, active);
+
+       apply_config((struct ui_psensor *)data);
 }
 
 void
 ui_sensorpref_appindicator_label_toggled_cb(GtkToggleButton *btn, gpointer data)
 {
        gboolean active;
-       struct cb_data *cbdata;
        struct psensor *s;
 
-       cbdata = (struct cb_data *)data;
+       if (ignore_changes)
+               return;
 
-       s = get_selected_sensor(cbdata->builder);
+       s = get_selected_sensor();
 
-       if (s) {
-               active = gtk_toggle_button_get_active(btn);
-               config_set_appindicator_label_enabled(s->id, active);
+       if (!s)
+               return;
 
-               apply_config(cbdata->ui);
-       }
+       active = gtk_toggle_button_get_active(btn);
+       config_set_appindicator_label_enabled(s->id, active);
+
+       apply_config((struct ui_psensor *)data);
 }
 
 void ui_sensorpref_color_set_cb(GtkColorButton *widget, gpointer data)
 {
-       struct cb_data *cbdata;
        struct psensor *s;
        GdkRGBA color;
 
-       cbdata = (struct cb_data *)data;
+       if (ignore_changes)
+               return;
 
-       s = get_selected_sensor(cbdata->builder);
+       s = get_selected_sensor();
+       if (!s)
+               return;
 
-       if (s) {
-               gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(widget), &color);
-               config_set_sensor_color(s->id, &color);
+       gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(widget), &color);
+       config_set_sensor_color(s->id, &color);
 
-               apply_config(cbdata->ui);
-       }
+       apply_config((struct ui_psensor *)data);
 }
 
 void
 ui_sensorpref_alarm_high_threshold_changed_cb(GtkSpinButton *btn, gpointer data)
 {
-       struct cb_data *cbdata;
        struct psensor *s;
        gdouble v;
 
-       cbdata = (struct cb_data *)data;
+       if (ignore_changes)
+               return;
 
-       s = get_selected_sensor(cbdata->builder);
+       s = get_selected_sensor();
+       if (!s)
+               return;
 
-       if (s) {
-               v = gtk_spin_button_get_value(btn);
-               config_set_sensor_alarm_high_threshold(s->id, v);
+       v = gtk_spin_button_get_value(btn);
+       if (config_get_sensor_unit() == FAHRENHEIT)
+               v = fahrenheit_to_celsius(v);
 
-               apply_config(cbdata->ui);
+       config_set_sensor_alarm_high_threshold(s->id, v);
+       s->alarm_high_threshold = v;
 
-               s->alarm_high_threshold = v;
-       }
+       apply_config((struct ui_psensor *)data);
 }
 
 void
 ui_sensorpref_alarm_low_threshold_changed_cb(GtkSpinButton *btn, gpointer data)
 {
-       struct cb_data *cbdata;
        struct psensor *s;
        gdouble v;
 
-       cbdata = (struct cb_data *)data;
+       if (ignore_changes)
+               return;
 
-       s = get_selected_sensor(cbdata->builder);
+       s = get_selected_sensor();
+       if (!s)
+               return;
 
-       if (s) {
-               v = gtk_spin_button_get_value(btn);
-               config_set_sensor_alarm_low_threshold(s->id, v);
+       v = gtk_spin_button_get_value(btn);
+       if (config_get_sensor_unit() == FAHRENHEIT)
+               v = fahrenheit_to_celsius(v);
 
-               apply_config(cbdata->ui);
+       config_set_sensor_alarm_low_threshold(s->id, v);
+       s->alarm_low_threshold = v;
 
-               s->alarm_low_threshold = v;
-       }
+       apply_config((struct ui_psensor *)data);
 }
 
-static void
-update_pref(struct psensor *s, struct config *cfg, GtkBuilder *builder)
+static void update_pref(struct psensor *s)
 {
-       GtkLabel *w_id, *w_type, *w_high_threshold_unit, *w_low_threshold_unit,
-               *w_chipname;
-       GtkEntry *w_name;
-       GtkToggleButton *w_draw, *w_alarm, *w_appindicator_enabled,
-               *w_appindicator_label_enabled, *w_display;
-       GtkColorButton *w_color;
-       GtkSpinButton *w_high_threshold, *w_low_threshold;
        int use_celsius, threshold;
        GdkRGBA *color;
+       const char *chip;
 
-       w_id = GTK_LABEL(gtk_builder_get_object(builder, "sensor_id"));
-       gtk_label_set_text(w_id, s->id);
+       if (!s)
+               return;
 
-       w_type = GTK_LABEL(gtk_builder_get_object(builder, "sensor_type"));
-       gtk_label_set_text(w_type, psensor_type_to_str(s->type));
+       ignore_changes = true;
 
-       w_name = GTK_ENTRY(gtk_builder_get_object(builder, "sensor_name"));
-       gtk_entry_set_text(w_name, s->name);
+       gtk_label_set_text(w_sensor_id, s->id);
+       gtk_label_set_text(w_sensor_type, psensor_type_to_str(s->type));
+       gtk_entry_set_text(w_sensor_name, s->name);
 
-       w_chipname = GTK_LABEL(gtk_builder_get_object(builder, "chip_name"));
        if (s->chip)
-               gtk_label_set_text(w_chipname, s->chip);
+               chip = s->chip;
        else
-               gtk_label_set_text(w_chipname, _("Unknown"));
+               chip = _("Unknown");
+       gtk_label_set_text(w_sensor_chipname, chip);
 
-       w_draw = GTK_TOGGLE_BUTTON(gtk_builder_get_object(builder,
-                                                         "sensor_draw"));
-       gtk_toggle_button_set_active(w_draw,
+       gtk_toggle_button_set_active(w_sensor_draw,
                                     config_is_sensor_graph_enabled(s->id));
 
-       w_display = GTK_TOGGLE_BUTTON(gtk_builder_get_object
-                                     (builder,
-                                      "sensor_enable_checkbox"));
-       gtk_toggle_button_set_active(w_display,
+       gtk_toggle_button_set_active(w_sensor_display,
                                     config_is_sensor_enabled(s->id));
 
-       w_color = GTK_COLOR_BUTTON(gtk_builder_get_object(builder,
-                                                         "sensor_color"));
        color = config_get_sensor_color(s->id);
-       gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(w_color), color);
+       gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(w_sensor_color), color);
        gdk_rgba_free(color);
 
-       w_alarm = GTK_TOGGLE_BUTTON(gtk_builder_get_object(builder,
-                                                          "sensor_alarm"));
-       w_high_threshold = GTK_SPIN_BUTTON(gtk_builder_get_object
-                                         (builder,
-                                          "sensor_alarm_high_threshold"));
-       w_low_threshold = GTK_SPIN_BUTTON(gtk_builder_get_object
-                                        (builder,
-                                         "sensor_alarm_low_threshold"));
-
-       w_high_threshold_unit = GTK_LABEL(gtk_builder_get_object
-                                        (builder,
-                                         "sensor_alarm_high_threshold_unit"));
-       w_low_threshold_unit = GTK_LABEL(gtk_builder_get_object
-                                       (builder,
-                                        "sensor_alarm_low_threshold_unit"));
-
-       use_celsius = cfg->temperature_unit == CELSIUS ? 1 : 0;
-       gtk_label_set_text(w_high_threshold_unit,
+       use_celsius = config_get_sensor_unit() == CELSIUS ? 1 : 0;
+       gtk_label_set_text(w_sensor_high_threshold_unit,
                           psensor_type_to_unit_str(s->type, use_celsius));
-       gtk_label_set_text(w_low_threshold_unit,
+       gtk_label_set_text(w_sensor_low_threshold_unit,
                           psensor_type_to_unit_str(s->type, use_celsius));
 
-       w_appindicator_enabled = GTK_TOGGLE_BUTTON
-               (gtk_builder_get_object(builder, "indicator_checkbox"));
-       w_appindicator_label_enabled = GTK_TOGGLE_BUTTON
-               (gtk_builder_get_object(builder, "indicator_label_checkbox"));
-
        if (is_appindicator_supported()) {
                gtk_widget_set_has_tooltip
                        (GTK_WIDGET(w_appindicator_label_enabled), FALSE);
@@ -329,22 +319,18 @@ update_pref(struct psensor *s, struct config *cfg, GtkBuilder *builder)
                        (GTK_WIDGET(w_appindicator_enabled), TRUE);
        }
 
-       gtk_toggle_button_set_active(w_alarm,
+       gtk_toggle_button_set_active(w_sensor_alarm,
                                     config_get_sensor_alarm_enabled(s->id));
 
        threshold = config_get_sensor_alarm_high_threshold(s->id);
        if (!use_celsius)
                threshold = celsius_to_fahrenheit(threshold);
-       gtk_spin_button_set_value(w_high_threshold, threshold);
+       gtk_spin_button_set_value(w_sensor_high_threshold, threshold);
 
        threshold = config_get_sensor_alarm_low_threshold(s->id);
        if (!use_celsius)
                threshold = celsius_to_fahrenheit(threshold);
-       gtk_spin_button_set_value(w_low_threshold, threshold);
-
-       gtk_widget_set_sensitive(GTK_WIDGET(w_alarm), TRUE);
-       gtk_widget_set_sensitive(GTK_WIDGET(w_high_threshold), TRUE);
-       gtk_widget_set_sensitive(GTK_WIDGET(w_low_threshold), TRUE);
+       gtk_spin_button_set_value(w_sensor_low_threshold, threshold);
 
        gtk_toggle_button_set_active(w_appindicator_enabled,
                                     config_is_appindicator_enabled(s->id));
@@ -352,61 +338,53 @@ update_pref(struct psensor *s, struct config *cfg, GtkBuilder *builder)
        gtk_toggle_button_set_active
                (w_appindicator_label_enabled,
                 config_is_appindicator_label_enabled(s->id));
+
+       ignore_changes = false;
 }
 
-static void on_changed(GtkTreeSelection *selection, gpointer data)
+void
+ui_sensorpref_tree_selection_changed_cb(GtkTreeSelection *sel, gpointer data)
 {
-       struct cb_data *cbdata = data;
-       struct ui_psensor *ui = cbdata->ui;
-       struct psensor *s;
-
-       s = get_selected_sensor(cbdata->builder);
-
-       update_pref(s, ui->config, cbdata->builder);
+       update_pref(get_selected_sensor());
 }
 
-static void
-select_sensor(struct psensor *s, struct psensor **sensors, GtkTreeView *tree)
+static void select_sensor(struct psensor *s, struct psensor **sensors)
 {
        struct psensor **s_cur;
        int i;
        GtkTreePath *p;
        GtkTreeSelection *sel;
 
-       p = NULL;
        for (s_cur = sensors, i = 0; *s_cur; s_cur++, i++)
                if (s == *s_cur) {
                        p = gtk_tree_path_new_from_indices(i, -1);
+                       sel = gtk_tree_view_get_selection(w_sensors_list);
+                       gtk_tree_selection_select_path(sel, p);
+
+                       gtk_tree_path_free(p);
+
+                       update_pref(s);
                        break;
                }
+}
 
-       if (p) {
-               sel = gtk_tree_view_get_selection(tree);
-
-               gtk_tree_selection_select_path(sel, p);
-               gtk_tree_path_free(p);
-       }
+static gboolean
+on_delete_event_cb(GtkWidget *widget, GdkEvent *event, gpointer data)
+{
+       gtk_widget_destroy(GTK_WIDGET(w_dialog));
+       w_dialog = NULL;
+       return TRUE;
 }
 
-void ui_sensorpref_dialog_run(struct psensor *sensor, struct ui_psensor *ui)
+static GtkBuilder *load_ui(struct ui_psensor *ui)
 {
-       GtkDialog *diag;
-       guint ok;
        GtkBuilder *builder;
        GError *error;
-       GtkTreeView *w_sensors_list;
-       GtkListStore *store;
-       struct psensor **s_cur, *s, **ordered_sensors;
-       GtkTreeSelection *selection;
-       struct cb_data cbdata;
-       GtkTreeIter iter;
+       guint ok;
 
-       cbdata.ui = ui;
+       error = NULL;
 
        builder = gtk_builder_new();
-       cbdata.builder = builder;
-
-       error = NULL;
        ok = gtk_builder_add_from_file
                (builder,
                 PACKAGE_DATA_DIR G_DIR_SEPARATOR_S "sensor-edit.glade",
@@ -415,17 +393,65 @@ void ui_sensorpref_dialog_run(struct psensor *sensor, struct ui_psensor *ui)
        if (!ok) {
                log_printf(LOG_ERR, error->message);
                g_error_free(error);
-               return;
+               return NULL;
        }
 
-       w_sensors_list
-               = GTK_TREE_VIEW(gtk_builder_get_object(builder,
-                                                      "sensors_list"));
+       w_sensors_list = GTK_TREE_VIEW
+               (gtk_builder_get_object(builder, "sensors_list"));
+       w_dialog = GTK_DIALOG(gtk_builder_get_object(builder, "dialog1"));
+       w_sensor_id = GTK_LABEL(gtk_builder_get_object(builder, "sensor_id"));
+       w_sensor_type = GTK_LABEL
+               (gtk_builder_get_object(builder, "sensor_type"));
+       w_sensor_name = GTK_ENTRY
+               (gtk_builder_get_object(builder, "sensor_name"));
+       w_sensor_chipname = GTK_LABEL
+               (gtk_builder_get_object(builder, "chip_name"));
+       w_sensor_draw = GTK_TOGGLE_BUTTON
+               (gtk_builder_get_object(builder, "sensor_draw"));
+       w_sensor_display = GTK_TOGGLE_BUTTON
+               (gtk_builder_get_object(builder, "sensor_enable_checkbox"));
+       w_sensor_color = GTK_COLOR_BUTTON
+               (gtk_builder_get_object(builder, "sensor_color"));
+       w_sensor_alarm = GTK_TOGGLE_BUTTON
+               (gtk_builder_get_object(builder, "sensor_alarm"));
+       w_sensor_high_threshold
+               = GTK_SPIN_BUTTON(gtk_builder_get_object
+                                 (builder, "sensor_alarm_high_threshold"));
+       w_sensor_low_threshold
+               = GTK_SPIN_BUTTON(gtk_builder_get_object
+                                 (builder, "sensor_alarm_low_threshold"));
+       w_sensor_high_threshold_unit
+               = GTK_LABEL(gtk_builder_get_object
+                           (builder, "sensor_alarm_high_threshold_unit"));
+       w_sensor_low_threshold_unit
+               = GTK_LABEL(gtk_builder_get_object
+                           (builder, "sensor_alarm_low_threshold_unit"));
+       w_appindicator_enabled = GTK_TOGGLE_BUTTON
+               (gtk_builder_get_object(builder, "indicator_checkbox"));
+       w_appindicator_label_enabled = GTK_TOGGLE_BUTTON
+               (gtk_builder_get_object(builder, "indicator_label_checkbox"));
 
        store = GTK_LIST_STORE(gtk_builder_get_object(builder,
                                                      "sensors_liststore"));
 
-       ordered_sensors = ui_get_sensors_ordered_by_position(ui);
+       gtk_builder_connect_signals(builder, ui);
+
+       g_signal_connect(w_dialog,
+                        "delete_event",
+                        G_CALLBACK(on_delete_event_cb),
+                        w_dialog);
+
+       return builder;
+}
+
+static void populate(struct psensor *sensor, struct psensor **sensors)
+{
+       GtkTreeIter iter;
+       struct psensor **s_cur, **ordered_sensors, *s;
+
+       gtk_list_store_clear(store);
+
+       ordered_sensors = ui_get_sensors_ordered_by_position(sensors);
        for (s_cur = ordered_sensors; *s_cur; s_cur++) {
                s = *s_cur;
                gtk_list_store_append(store, &iter);
@@ -434,24 +460,27 @@ void ui_sensorpref_dialog_run(struct psensor *sensor, struct ui_psensor *ui)
                                   COL_NAME, s->name,
                                   COL_SENSOR_PREF, s,
                                   -1);
-
-               if (s == sensor)
-                       update_pref(s, ui->config, builder);
        }
 
-       selection = gtk_tree_view_get_selection(w_sensors_list);
-       g_signal_connect(selection, "changed", G_CALLBACK(on_changed), &cbdata);
-       select_sensor(sensor, ordered_sensors, w_sensors_list);
+       select_sensor(sensor, ordered_sensors);
 
        free(ordered_sensors);
+}
 
-       diag = GTK_DIALOG(gtk_builder_get_object(builder, "dialog1"));
+void ui_sensorpref_dialog_run(struct psensor *sensor, struct ui_psensor *ui)
+{
+       GtkBuilder *builder;
 
-       gtk_builder_connect_signals(builder, &cbdata);
+       if (w_dialog == NULL) {
+               builder = load_ui(ui);
 
-       gtk_dialog_run(diag);
+               if (!builder)
+                       return;
+
+               g_object_unref(G_OBJECT(builder));
+       }
 
-       g_object_unref(G_OBJECT(builder));
+       populate(sensor, ui->sensors);
 
-       gtk_widget_destroy(GTK_WIDGET(diag));
+       gtk_window_present(GTK_WINDOW(w_dialog));
 }

diff --git a/src/ui_sensorpref.h b/src/ui_sensorpref.h
index e433f4a..25ac0f2 100644 (file)
--- a/src/ui_sensorpref.h
+++ b/src/ui_sensorpref.h
@@ -32,5 +32,6 @@ void ui_sensorpref_appindicator_label_toggled_cb(GtkToggleButton *, gpointer);
 void ui_sensorpref_color_set_cb(GtkColorButton *, gpointer);
 void ui_sensorpref_alarm_high_threshold_changed_cb(GtkSpinButton *, gpointer);
 void ui_sensorpref_alarm_low_threshold_changed_cb(GtkSpinButton *, gpointer);
+void ui_sensorpref_tree_selection_changed_cb(GtkTreeSelection *, gpointer);
 
 #endif