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