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         gtk_toggle_button_set_active(w_alarm, p->alarm_enabled);
 294         gtk_spin_button_set_value(w_high_threshold, p->alarm_high_threshold);
 295         gtk_spin_button_set_value(w_low_threshold, p->alarm_low_threshold);
 296         gtk_widget_set_sensitive(GTK_WIDGET(w_alarm), TRUE);
 297         gtk_widget_set_sensitive(GTK_WIDGET(w_high_threshold), TRUE);
 298         gtk_widget_set_sensitive(GTK_WIDGET(w_low_threshold), TRUE);
 299
 300         gtk_toggle_button_set_active(w_appindicator_enabled,
 301                                      p->appindicator_enabled);
 302
 303         gtk_toggle_button_set_active(w_appindicator_label_enabled,
 304                                      p->appindicator_label_enabled);
 305 }
 306
 307 static void on_changed(GtkTreeSelection *selection, gpointer data)
 308 {
 309         struct cb_data *cbdata = data;
 310         struct ui_psensor *ui = cbdata->ui;
 311         struct sensor_pref *p;
 312         GtkTreeView *tree;
 313
 314         tree = GTK_TREE_VIEW(gtk_builder_get_object(cbdata->builder,
 315                                                     "sensors_list"));
 316         p = get_selected_sensor_pref(tree);
 317         update_pref(p, ui->config, cbdata->builder);
 318 }
 319
 320 static void
 321 select_sensor(struct psensor *s, struct psensor **sensors, GtkTreeView *tree)
 322 {
 323         struct psensor **s_cur;
 324         int i;
 325         GtkTreePath *p;
 326
 327         p = NULL;
 328         for (s_cur = sensors, i = 0; *s_cur; s_cur++, i++)
 329                 if (s == *s_cur) {
 330                         p = gtk_tree_path_new_from_indices(i, -1);
 331                         break;
 332                 }
 333
 334         if (p) {
 335                 GtkTreeSelection *s = gtk_tree_view_get_selection(tree);
 336
 337                 gtk_tree_selection_select_path(s, p);
 338                 gtk_tree_path_free(p);
 339         }
 340 }
 341
 342 static void apply_pref(struct sensor_pref *p, int pos, struct config *cfg)
 343 {
 344         struct psensor *s;
 345
 346         s = p->sensor;
 347
 348         if (strcmp(p->name, s->name)) {
 349                 free(s->name);
 350                 s->name = strdup(p->name);
 351                 config_set_sensor_name(s->id, s->name);
 352         }
 353
 354         if (s->graph_enabled != p->graph_enabled) {
 355                 s->graph_enabled = p->graph_enabled;
 356                 config_set_sensor_graph_enabled(s->id, s->graph_enabled);
 357         }
 358
 359         if (is_temp_type(s->type) && cfg->temperature_unit == FAHRENHEIT) {
 360                 s->alarm_high_threshold
 361                         = fahrenheit_to_celsius(p->alarm_high_threshold);
 362                 s->alarm_low_threshold
 363                         = fahrenheit_to_celsius(p->alarm_low_threshold);
 364         } else {
 365                 s->alarm_high_threshold = p->alarm_high_threshold;
 366                 s->alarm_low_threshold = p->alarm_low_threshold;
 367         }
 368
 369         config_set_sensor_alarm_high_threshold(s->id, s->alarm_high_threshold);
 370         config_set_sensor_alarm_low_threshold(s->id, s->alarm_low_threshold);
 371
 372         if (s->alarm_enabled != p->alarm_enabled) {
 373                 s->alarm_enabled = p->alarm_enabled;
 374                 config_set_sensor_alarm_enabled(s->id, s->alarm_enabled);
 375         }
 376
 377         color_set(s->color,
 378                   p->color->red,
 379                   p->color->green,
 380                   p->color->blue);
 381         config_set_sensor_color(s->id, s->color);
 382
 383         if (s->appindicator_enabled != p->appindicator_enabled) {
 384                 s->appindicator_enabled = p->appindicator_enabled;
 385                 config_set_appindicator_enabled(s->id, s->appindicator_enabled);
 386         }
 387
 388         config_set_appindicator_label_enabled(s->id,
 389                                               p->appindicator_label_enabled);
 390
 391         config_set_sensor_position(s->id, pos);
 392
 393         config_set_sensor_enabled(s->id, p->display_enabled);
 394 }
 395
 396 static void apply_prefs(GtkTreeModel *model, struct config *cfg)
 397 {
 398         gboolean valid;
 399         struct sensor_pref *spref;
 400         GtkTreeIter iter;
 401         int i;
 402
 403         valid = gtk_tree_model_get_iter_first(model, &iter);
 404         i = 0;
 405         while (valid) {
 406                 gtk_tree_model_get(model, &iter, COL_SENSOR_PREF, &spref, -1);
 407                 apply_pref(spref, i, cfg);
 408                 valid = gtk_tree_model_iter_next(model, &iter);
 409                 i++;
 410         }
 411         config_sync();
 412 }
 413
 414 void ui_sensorpref_dialog_run(struct psensor *sensor, struct ui_psensor *ui)
 415 {
 416         GtkDialog *diag;
 417         gint result;
 418         guint ok;
 419         GtkBuilder *builder;
 420         GError *error;
 421         GtkTreeView *w_sensors_list;
 422         GtkListStore *store;
 423         struct psensor **s_cur, *s, **ordered_sensors;
 424         GtkTreeSelection *selection;
 425         struct cb_data cbdata;
 426         GtkTreeIter iter;
 427         struct sensor_pref *spref;
 428         gboolean valid;
 429         GtkTreeModel *model;
 430
 431         cbdata.ui = ui;
 432
 433         builder = gtk_builder_new();
 434         cbdata.builder = builder;
 435
 436         error = NULL;
 437         ok = gtk_builder_add_from_file
 438                 (builder,
 439                  PACKAGE_DATA_DIR G_DIR_SEPARATOR_S "sensor-edit.glade",
 440                  &error);
 441
 442         if (!ok) {
 443                 log_printf(LOG_ERR, error->message);
 444                 g_error_free(error);
 445                 return;
 446         }
 447
 448         w_sensors_list
 449                 = GTK_TREE_VIEW(gtk_builder_get_object(builder,
 450                                                        "sensors_list"));
 451         gtk_builder_connect_signals(builder, w_sensors_list);
 452
 453         store = GTK_LIST_STORE(gtk_builder_get_object(builder,
 454                                                       "sensors_liststore"));
 455
 456         ordered_sensors = ui_get_sensors_ordered_by_position(ui);
 457         for (s_cur = ordered_sensors; *s_cur; s_cur++) {
 458                 s = *s_cur;
 459                 gtk_list_store_append(store, &iter);
 460
 461                 spref = sensor_pref_new(s, ui->config);
 462                 gtk_list_store_set(store, &iter,
 463                                    COL_NAME, s->name,
 464                                    COL_SENSOR_PREF, spref,
 465                                    -1);
 466
 467                 if (s == sensor)
 468                         update_pref(spref, ui->config, builder);
 469         }
 470
 471         selection = gtk_tree_view_get_selection(w_sensors_list);
 472         g_signal_connect(selection, "changed", G_CALLBACK(on_changed), &cbdata);
 473         select_sensor(sensor, ordered_sensors, w_sensors_list);
 474
 475         free(ordered_sensors);
 476
 477         diag = GTK_DIALOG(gtk_builder_get_object(builder, "dialog1"));
 478         result = gtk_dialog_run(diag);
 479
 480         model = gtk_tree_view_get_model(w_sensors_list);
 481
 482         if (result == GTK_RESPONSE_ACCEPT) {
 483                 apply_prefs(model, ui->config);
 484                 ui_sensorlist_update(ui, 1);
 485 #if defined(HAVE_APPINDICATOR) || defined(HAVE_APPINDICATOR_029)
 486                 ui_appindicator_update_menu(ui);
 487 #endif
 488         }
 489
 490         valid = gtk_tree_model_get_iter_first(model, &iter);
 491         while (valid) {
 492                 gtk_tree_model_get(model, &iter, COL_SENSOR_PREF, &spref, -1);
 493                 sensor_pref_free(spref);
 494                 valid = gtk_tree_model_iter_next(model, &iter);
 495         }
 496
 497         g_object_unref(G_OBJECT(builder));
 498
 499         gtk_widget_destroy(GTK_WIDGET(diag));
 500 }