src/ui_sensorpref.c

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