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