src/ui_sensorpref.c

   1 /*
   2  * Copyright (C) 2010-2014 jeanfi@gmail.com
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  17  * 02110-1301 USA
  18  */
  19 #include <stdlib.h>
  20
  21 #include <gtk/gtk.h>
  22
  23 #include <cfg.h>
  24 #include <temperature.h>
  25 #include <ui_pref.h>
  26 #include <ui_sensorlist.h>
  27 #include <ui_sensorpref.h>
  28 #include <ui_color.h>
  29
  30
  31 #if defined(HAVE_APPINDICATOR) || defined(HAVE_APPINDICATOR_029)
  32 #include "ui_appindicator.h"
  33 #endif
  34
  35 enum {
  36         COL_NAME = 0,
  37         COL_SENSOR_PREF
  38 };
  39
  40 struct sensor_pref {
  41         struct psensor *sensor;
  42         char *name;
  43         int graph_enabled;
  44         struct color *color;
  45         int alarm_enabled;
  46         int alarm_high_threshold;
  47         int alarm_low_threshold;
  48         unsigned int appindicator_enabled;
  49         unsigned int appindicator_label_enabled;
  50         unsigned int display_enabled;
  51 };
  52
  53 struct cb_data {
  54         struct ui_psensor *ui;
  55         GtkBuilder *builder;
  56 };
  57
  58 static struct sensor_pref *
  59 sensor_pref_new(struct psensor *s, struct config *cfg)
  60 {
  61         struct sensor_pref *p;
  62
  63         p = malloc(sizeof(struct sensor_pref));
  64
  65         p->sensor = s;
  66         p->name = strdup(s->name);
  67         p->graph_enabled = s->graph_enabled;
  68         p->alarm_enabled = s->alarm_enabled;
  69         p->color = color_dup(s->color);
  70         p->display_enabled = config_is_sensor_enabled(s->id);
  71
  72         if (cfg->temperature_unit == CELSIUS) {
  73                 p->alarm_high_threshold = s->alarm_high_threshold;
  74                 p->alarm_low_threshold = s->alarm_low_threshold;
  75         } else {
  76                 p->alarm_high_threshold
  77                         = celsius_to_fahrenheit(s->alarm_high_threshold);
  78                 p->alarm_low_threshold
  79                         = celsius_to_fahrenheit(s->alarm_low_threshold);
  80         }
  81
  82         p->appindicator_enabled = s->appindicator_enabled;
  83         p->appindicator_label_enabled
  84                 = config_is_appindicator_label_enabled(s->id);
  85
  86         return p;
  87 }
  88
  89 static void sensor_pref_free(struct sensor_pref *p)
  90 {
  91         if (!p)
  92                 return ;
  93
  94         free(p->name);
  95         free(p->color);
  96
  97         free(p);
  98 }
  99
 100 static struct sensor_pref *get_selected_sensor_pref(GtkTreeView *tree)
 101 {
 102         GtkTreeModel *model;
 103         GtkTreeIter iter;
 104         struct sensor_pref *pref;
 105         GtkTreeSelection *selection;
 106
 107         selection = gtk_tree_view_get_selection(tree);
 108
 109         pref = NULL;
 110         if (gtk_tree_selection_get_selected(selection, &model, &iter))
 111                 gtk_tree_model_get(model, &iter, COL_SENSOR_PREF, &pref, -1);
 112
 113         return pref;
 114 }
 115
 116 void ui_sensorpref_name_changed_cb(GtkEntry *entry, gpointer data)
 117 {
 118         struct sensor_pref *p;
 119         const char *str;
 120
 121         str = gtk_entry_get_text(entry);
 122
 123         p = get_selected_sensor_pref(GTK_TREE_VIEW(data));
 124
 125         if (p && strcmp(p->name, str)) {
 126                 free(p->name);
 127                 p->name = strdup(str);
 128         }
 129 }
 130
 131 void ui_sensorpref_draw_toggled_cb(GtkToggleButton *btn, gpointer data)
 132 {
 133         struct sensor_pref *p;
 134
 135         p = get_selected_sensor_pref(GTK_TREE_VIEW(data));
 136
 137         if (p)
 138                 p->graph_enabled = gtk_toggle_button_get_active(btn);
 139 }
 140
 141 void ui_sensorpref_display_toggled_cb(GtkToggleButton *btn, gpointer data)
 142 {
 143         struct sensor_pref *p;
 144
 145         p = get_selected_sensor_pref(GTK_TREE_VIEW(data));
 146
 147         if (p)
 148                 p->display_enabled = gtk_toggle_button_get_active(btn);
 149 }
 150
 151 void ui_sensorpref_alarm_toggled_cb(GtkToggleButton *btn, gpointer data)
 152 {
 153         struct sensor_pref *p;
 154
 155         p = get_selected_sensor_pref(GTK_TREE_VIEW(data));
 156
 157         if (p)
 158                 p->alarm_enabled = gtk_toggle_button_get_active(btn);
 159 }
 160
 161 void
 162 ui_sensorpref_appindicator_menu_toggled_cb(GtkToggleButton *btn, gpointer data)
 163 {
 164         struct sensor_pref *p;
 165
 166         p = get_selected_sensor_pref(GTK_TREE_VIEW(data));
 167
 168         if (p)
 169                 p->appindicator_enabled = gtk_toggle_button_get_active(btn);
 170 }
 171
 172 void
 173 ui_sensorpref_appindicator_label_toggled_cb(GtkToggleButton *btn, gpointer data)
 174 {
 175         struct sensor_pref *p;
 176
 177         p = get_selected_sensor_pref(GTK_TREE_VIEW(data));
 178
 179         if (p)
 180                 p->appindicator_label_enabled
 181                         = gtk_toggle_button_get_active(btn);
 182 }
 183
 184 void ui_sensorpref_color_set_cb(GtkColorButton *widget, gpointer data)
 185 {
 186         struct sensor_pref *p;
 187         GdkRGBA color;
 188
 189         p = get_selected_sensor_pref(GTK_TREE_VIEW(data));
 190
 191         if (p) {
 192                 gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(widget), &color);
 193                 color_set(p->color, color.red, color.green, color.blue);
 194         }
 195 }
 196
 197 void
 198 ui_sensorpref_alarm_high_threshold_changed_cb(GtkSpinButton *btn, gpointer data)
 199 {
 200         struct sensor_pref *p;
 201
 202         p = get_selected_sensor_pref(GTK_TREE_VIEW(data));
 203
 204         if (p)
 205                 p->alarm_high_threshold = gtk_spin_button_get_value(btn);
 206 }
 207
 208 void
 209 ui_sensorpref_alarm_low_threshold_changed_cb(GtkSpinButton *btn, gpointer data)
 210 {
 211         struct sensor_pref *p;
 212
 213         p = get_selected_sensor_pref(GTK_TREE_VIEW(data));
 214
 215         if (p)
 216                 p->alarm_low_threshold = gtk_spin_button_get_value(btn);
 217 }
 218
 219 static void
 220 update_pref(struct sensor_pref *p, struct config *cfg, GtkBuilder *builder)
 221 {
 222         GtkLabel *w_id, *w_type, *w_high_threshold_unit, *w_low_threshold_unit,
 223                 *w_chipname;
 224         GtkEntry *w_name;
 225         GtkToggleButton *w_draw, *w_alarm, *w_appindicator_enabled,
 226                 *w_appindicator_label_enabled, *w_display;
 227         GtkColorButton *w_color;
 228         GtkSpinButton *w_high_threshold, *w_low_threshold;
 229         GdkRGBA color;
 230         struct psensor *s;
 231         int use_celsius;
 232
 233         s = p->sensor;
 234
 235         w_id = GTK_LABEL(gtk_builder_get_object(builder, "sensor_id"));
 236         gtk_label_set_text(w_id, s->id);
 237
 238         w_type = GTK_LABEL(gtk_builder_get_object(builder, "sensor_type"));
 239         gtk_label_set_text(w_type, psensor_type_to_str(s->type));
 240
 241         w_name = GTK_ENTRY(gtk_builder_get_object(builder, "sensor_name"));
 242         gtk_entry_set_text(w_name, p->name);
 243
 244         w_chipname = GTK_LABEL(gtk_builder_get_object(builder, "chip_name"));
 245         if (s->chip)
 246                 gtk_label_set_text(w_chipname, s->chip);
 247         else
 248                 gtk_label_set_text(w_chipname, _("Unknown"));
 249
 250         w_draw = GTK_TOGGLE_BUTTON(gtk_builder_get_object(builder,
 251                                                           "sensor_draw"));
 252         gtk_toggle_button_set_active(w_draw, p->graph_enabled);
 253
 254         w_display = GTK_TOGGLE_BUTTON(gtk_builder_get_object
 255                                       (builder,
 256                                        "sensor_enable_checkbox"));
 257         gtk_toggle_button_set_active(w_display, p->display_enabled);
 258
 259         color = color_to_GdkRGBA(p->color);
 260         w_color = GTK_COLOR_BUTTON(gtk_builder_get_object(builder,
 261                                                           "sensor_color"));
 262         gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(w_color), &color);
 263
 264         w_alarm = GTK_TOGGLE_BUTTON(gtk_builder_get_object(builder,
 265                                                            "sensor_alarm"));
 266         w_high_threshold = GTK_SPIN_BUTTON(gtk_builder_get_object
 267                                           (builder,
 268                                            "sensor_alarm_high_threshold"));
 269         w_low_threshold = GTK_SPIN_BUTTON(gtk_builder_get_object
 270                                          (builder,
 271                                           "sensor_alarm_low_threshold"));
 272
 273         w_high_threshold_unit = GTK_LABEL(gtk_builder_get_object
 274                                          (builder,
 275                                           "sensor_alarm_high_threshold_unit"));
 276         w_low_threshold_unit = GTK_LABEL(gtk_builder_get_object
 277                                         (builder,
 278                                          "sensor_alarm_low_threshold_unit"));
 279
 280         use_celsius = cfg->temperature_unit == CELSIUS ? 1 : 0;
 281         gtk_label_set_text(w_high_threshold_unit,
 282                            psensor_type_to_unit_str(s->type,
 283                                                     use_celsius));
 284         gtk_label_set_text(w_low_threshold_unit,
 285                            psensor_type_to_unit_str(s->type,
 286                                                     use_celsius));
 287
 288         w_appindicator_enabled = GTK_TOGGLE_BUTTON
 289                 (gtk_builder_get_object(builder, "indicator_checkbox"));
 290         w_appindicator_label_enabled = GTK_TOGGLE_BUTTON
 291                 (gtk_builder_get_object(builder, "indicator_label_checkbox"));
 292
 293         if (is_temp_type(s->type) || is_fan_type(s->type)) {
 294                 gtk_toggle_button_set_active(w_alarm, p->alarm_enabled);
 295                 gtk_spin_button_set_value(w_high_threshold,
 296                                           p->alarm_high_threshold);
 297                 gtk_spin_button_set_value(w_low_threshold,
 298                                           p->alarm_low_threshold);
 299                 gtk_widget_set_sensitive(GTK_WIDGET(w_alarm), TRUE);
 300                 gtk_widget_set_sensitive(GTK_WIDGET(w_high_threshold), TRUE);
 301                 gtk_widget_set_sensitive(GTK_WIDGET(w_low_threshold), TRUE);
 302         } else {
 303                 gtk_toggle_button_set_active(w_alarm, 0);
 304                 gtk_spin_button_set_value(w_high_threshold, 0);
 305                 gtk_spin_button_set_value(w_low_threshold, 0);
 306                 gtk_widget_set_sensitive(GTK_WIDGET(w_alarm), FALSE);
 307                 gtk_widget_set_sensitive(GTK_WIDGET(w_high_threshold), FALSE);
 308                 gtk_widget_set_sensitive(GTK_WIDGET(w_low_threshold), FALSE);
 309         }
 310
 311         gtk_toggle_button_set_active(w_appindicator_enabled,
 312                                      p->appindicator_enabled);
 313
 314         gtk_toggle_button_set_active(w_appindicator_label_enabled,
 315                                      p->appindicator_label_enabled);
 316 }
 317
 318 static void on_changed(GtkTreeSelection *selection, gpointer data)
 319 {
 320         struct cb_data *cbdata = data;
 321         struct ui_psensor *ui = cbdata->ui;
 322         struct sensor_pref *p;
 323         GtkTreeView *tree;
 324
 325         tree = GTK_TREE_VIEW(gtk_builder_get_object(cbdata->builder,
 326                                                     "sensors_list"));
 327         p = get_selected_sensor_pref(tree);
 328         update_pref(p, ui->config, cbdata->builder);
 329 }
 330
 331 static void
 332 select_sensor(struct psensor *s, struct psensor **sensors, GtkTreeView *tree)
 333 {
 334         struct psensor **s_cur;
 335         int i;
 336         GtkTreePath *p;
 337
 338         p = NULL;
 339         for (s_cur = sensors, i = 0; *s_cur; s_cur++, i++)
 340                 if (s == *s_cur) {
 341                         p = gtk_tree_path_new_from_indices(i, -1);
 342                         break;
 343                 }
 344
 345         if (p) {
 346                 GtkTreeSelection *s = gtk_tree_view_get_selection(tree);
 347
 348                 gtk_tree_selection_select_path(s, p);
 349                 gtk_tree_path_free(p);
 350         }
 351 }
 352
 353 static void apply_pref(struct sensor_pref *p, int pos, struct config *cfg)
 354 {
 355         struct psensor *s;
 356
 357         s = p->sensor;
 358
 359         if (strcmp(p->name, s->name)) {
 360                 free(s->name);
 361                 s->name = strdup(p->name);
 362                 config_set_sensor_name(s->id, s->name);
 363         }
 364
 365         if (s->graph_enabled != p->graph_enabled) {
 366                 s->graph_enabled = p->graph_enabled;
 367                 config_set_sensor_graph_enabled(s->id, s->graph_enabled);
 368         }
 369
 370         if (is_temp_type(s->type) && cfg->temperature_unit == FAHRENHEIT) {
 371                 s->alarm_high_threshold
 372                         = fahrenheit_to_celsius(p->alarm_high_threshold);
 373                 s->alarm_low_threshold
 374                         = fahrenheit_to_celsius(p->alarm_low_threshold);
 375         } else {
 376                 s->alarm_high_threshold = p->alarm_high_threshold;
 377                 s->alarm_low_threshold = p->alarm_low_threshold;
 378         }
 379
 380         config_set_sensor_alarm_high_threshold(s->id, s->alarm_high_threshold);
 381         config_set_sensor_alarm_low_threshold(s->id, s->alarm_low_threshold);
 382
 383         if (s->alarm_enabled != p->alarm_enabled) {
 384                 s->alarm_enabled = p->alarm_enabled;
 385                 config_set_sensor_alarm_enabled(s->id, s->alarm_enabled);
 386         }
 387
 388         color_set(s->color,
 389                   p->color->red,
 390                   p->color->green,
 391                   p->color->blue);
 392         config_set_sensor_color(s->id, s->color);
 393
 394         if (s->appindicator_enabled != p->appindicator_enabled) {
 395                 s->appindicator_enabled = p->appindicator_enabled;
 396                 config_set_appindicator_enabled(s->id, s->appindicator_enabled);
 397         }
 398
 399         config_set_appindicator_label_enabled(s->id,
 400                                               p->appindicator_label_enabled);
 401
 402         config_set_sensor_position(s->id, pos);
 403
 404         config_set_sensor_enabled(s->id, p->display_enabled);
 405 }
 406
 407 static void apply_prefs(GtkTreeModel *model, struct config *cfg)
 408 {
 409         gboolean valid;
 410         struct sensor_pref *spref;
 411         GtkTreeIter iter;
 412         int i;
 413
 414         valid = gtk_tree_model_get_iter_first(model, &iter);
 415         i = 0;
 416         while (valid) {
 417                 gtk_tree_model_get(model, &iter, COL_SENSOR_PREF, &spref, -1);
 418                 apply_pref(spref, i, cfg);
 419                 valid = gtk_tree_model_iter_next(model, &iter);
 420                 i++;
 421         }
 422         config_sync();
 423 }
 424
 425 void ui_sensorpref_dialog_run(struct psensor *sensor, struct ui_psensor *ui)
 426 {
 427         GtkDialog *diag;
 428         gint result;
 429         guint ok;
 430         GtkBuilder *builder;
 431         GError *error;
 432         GtkTreeView *w_sensors_list;
 433         GtkListStore *store;
 434         struct psensor **s_cur, *s, **ordered_sensors;
 435         GtkTreeSelection *selection;
 436         struct cb_data cbdata;
 437         GtkTreeIter iter;
 438         struct sensor_pref *spref;
 439         gboolean valid;
 440         GtkTreeModel *model;
 441
 442         cbdata.ui = ui;
 443
 444         builder = gtk_builder_new();
 445         cbdata.builder = builder;
 446
 447         error = NULL;
 448         ok = gtk_builder_add_from_file
 449                 (builder,
 450                  PACKAGE_DATA_DIR G_DIR_SEPARATOR_S "sensor-edit.glade",
 451                  &error);
 452
 453         if (!ok) {
 454                 log_printf(LOG_ERR, error->message);
 455                 g_error_free(error);
 456                 return ;
 457         }
 458
 459         w_sensors_list
 460                 = GTK_TREE_VIEW(gtk_builder_get_object(builder,
 461                                                        "sensors_list"));
 462         gtk_builder_connect_signals(builder, w_sensors_list);
 463
 464         store = GTK_LIST_STORE(gtk_builder_get_object(builder,
 465                                                       "sensors_liststore"));
 466
 467         ordered_sensors = ui_get_sensors_ordered_by_position(ui);
 468         for (s_cur = ordered_sensors; *s_cur; s_cur++) {
 469                 s = *s_cur;
 470                 gtk_list_store_append(store, &iter);
 471
 472                 spref = sensor_pref_new(s, ui->config);
 473                 gtk_list_store_set(store, &iter,
 474                                    COL_NAME, s->name,
 475                                    COL_SENSOR_PREF, spref,
 476                                    -1);
 477
 478                 if (s == sensor)
 479                         update_pref(spref, ui->config, builder);
 480         }
 481
 482         selection = gtk_tree_view_get_selection(w_sensors_list);
 483         g_signal_connect(selection, "changed", G_CALLBACK(on_changed), &cbdata);
 484         select_sensor(sensor, ordered_sensors, w_sensors_list);
 485
 486         free(ordered_sensors);
 487
 488         diag = GTK_DIALOG(gtk_builder_get_object(builder, "dialog1"));
 489         result = gtk_dialog_run(diag);
 490
 491         model = gtk_tree_view_get_model(w_sensors_list);
 492
 493         if (result == GTK_RESPONSE_ACCEPT) {
 494                 apply_prefs(model, ui->config);
 495                 ui_sensorlist_update(ui, 1);
 496 #if defined(HAVE_APPINDICATOR) || defined(HAVE_APPINDICATOR_029)
 497                 ui_appindicator_update_menu(ui);
 498 #endif
 499         }
 500
 501         valid = gtk_tree_model_get_iter_first(model, &iter);
 502         while (valid) {
 503                 gtk_tree_model_get(model, &iter, COL_SENSOR_PREF, &spref, -1);
 504                 sensor_pref_free(spref);
 505                 valid = gtk_tree_model_iter_next(model, &iter);
 506         }
 507
 508         g_object_unref(G_OBJECT(builder));
 509
 510         gtk_widget_destroy(GTK_WIDGET(diag));
 511 }