src/ui_sensorpref.c

   1 /*
   2  * Copyright (C) 2010-2012 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 struct sensor_pref {
  30         struct psensor *sensor;
  31         char *name;
  32         int enabled;
  33         struct color *color;
  34         int alarm_enabled;
  35         double alarm_limit;
  36 };
  37
  38 struct cb_data {
  39         struct ui_psensor *ui;
  40         GtkBuilder *builder;
  41         struct sensor_pref **prefs;
  42 };
  43
  44 static struct sensor_pref *sensor_pref_new(struct psensor *s,
  45                                            struct config *cfg)
  46 {
  47         struct sensor_pref *p = malloc(sizeof(struct sensor_pref));
  48
  49         p->sensor = s;
  50
  51         p->name = strdup(s->name);
  52         p->enabled = s->enabled;
  53         p->alarm_enabled = s->alarm_enabled;
  54         p->color = color_dup(s->color);
  55
  56         if (cfg->temperature_unit == CELCIUS)
  57                 p->alarm_limit = s->alarm_limit;
  58         else
  59                 p->alarm_limit = celcius_to_fahrenheit(s->alarm_limit);
  60
  61         return p;
  62 }
  63
  64 static void sensor_pref_free(struct sensor_pref *p)
  65 {
  66         if (!p)
  67                 return ;
  68
  69         free(p->name);
  70         free(p->color);
  71
  72         free(p);
  73 }
  74
  75 static struct sensor_pref **sensor_pref_list_new(struct psensor **sensors,
  76                                                  struct config *cfg)
  77 {
  78         int n, i;
  79         struct sensor_pref **pref_list;
  80
  81         n = psensor_list_size(sensors);
  82         pref_list = malloc(sizeof(struct sensor_pref *) * (n+1));
  83
  84         for (i = 0; i < n; i++)
  85                 pref_list[i] = sensor_pref_new(sensors[i],
  86                                                cfg);
  87
  88         pref_list[n] = NULL;
  89
  90         return pref_list;
  91 }
  92
  93 static void sensor_pref_list_free(struct sensor_pref **list)
  94 {
  95         struct sensor_pref **cur = list;
  96
  97         while (*cur) {
  98                 sensor_pref_free(*cur);
  99
 100                 cur++;
 101         }
 102
 103         free(list);
 104 }
 105
 106 static struct sensor_pref *
 107 sensor_pref_get(struct sensor_pref **ps, struct psensor *s)
 108 {
 109         struct sensor_pref **p_cur = ps;
 110
 111         while (*p_cur) {
 112                 struct sensor_pref *p = *p_cur;
 113
 114                 if (p->sensor == s)
 115                         return p;
 116
 117                 p_cur++;
 118         }
 119
 120         return NULL;
 121 }
 122
 123 static struct sensor_pref *
 124 get_selected_sensor_pref(GtkBuilder *builder, struct sensor_pref **ps)
 125 {
 126         GtkTreeModel *model;
 127         GtkTreeIter iter;
 128         struct sensor_pref *pref = NULL;
 129         GtkTreeSelection *selection;
 130         GtkTreeView *tree;
 131
 132         tree = GTK_TREE_VIEW(gtk_builder_get_object(builder,
 133                                      "sensors_list"));
 134
 135         selection = gtk_tree_view_get_selection(tree);
 136
 137         if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
 138                 GtkTreePath *p = gtk_tree_model_get_path(model, &iter);
 139                 gint *indices = gtk_tree_path_get_indices(p);
 140
 141                 pref = ps[*indices];
 142
 143                 gtk_tree_path_free(p);
 144         }
 145
 146         return pref;
 147 }
 148
 149 static void on_name_changed(GtkEntry *entry, gpointer data)
 150 {
 151         struct cb_data *cbdata = data;
 152         struct sensor_pref *p;
 153         const char *str;
 154
 155         str = gtk_entry_get_text(entry);
 156
 157         p = get_selected_sensor_pref(cbdata->builder, cbdata->prefs);
 158
 159         if (p && strcmp(p->name, str)) {
 160                 free(p->name);
 161                 p->name = strdup(str);
 162         }
 163 }
 164
 165 static void
 166 on_drawed_toggled(GtkToggleButton *btn, gpointer data)
 167 {
 168         struct cb_data *cbdata = data;
 169         struct sensor_pref *p;
 170
 171         p = get_selected_sensor_pref(cbdata->builder, cbdata->prefs);
 172
 173         if (p)
 174                 p->enabled = gtk_toggle_button_get_active(btn);
 175 }
 176
 177 static void
 178 on_alarm_toggled(GtkToggleButton *btn, gpointer data)
 179 {
 180         struct cb_data *cbdata = data;
 181         struct sensor_pref *p;
 182
 183         p = get_selected_sensor_pref(cbdata->builder, cbdata->prefs);
 184
 185         if (p)
 186                 p->alarm_enabled = gtk_toggle_button_get_active(btn);
 187 }
 188
 189 static void on_color_set(GtkColorButton *widget, gpointer data)
 190 {
 191         struct cb_data *cbdata = data;
 192         struct sensor_pref *p;
 193         GdkColor color;
 194
 195         p = get_selected_sensor_pref(cbdata->builder, cbdata->prefs);
 196
 197         if (p) {
 198                 gtk_color_button_get_color(widget, &color);
 199                 color_set(p->color, color.red, color.green, color.blue);
 200         }
 201 }
 202
 203 static void on_temp_limit_changed(GtkSpinButton *btn, gpointer data)
 204 {
 205         struct cb_data *cbdata = data;
 206         struct sensor_pref *p;
 207
 208         p = get_selected_sensor_pref(cbdata->builder, cbdata->prefs);
 209
 210         if (p)
 211                 p->alarm_limit = gtk_spin_button_get_value(btn);
 212 }
 213
 214 static void connect_signals(GtkBuilder *builder, struct cb_data *cbdata)
 215 {
 216         g_signal_connect(gtk_builder_get_object(builder, "sensor_name"),
 217                          "changed", G_CALLBACK(on_name_changed), cbdata);
 218
 219         g_signal_connect(gtk_builder_get_object(builder, "sensor_draw"),
 220                          "toggled", G_CALLBACK(on_drawed_toggled), cbdata);
 221
 222         g_signal_connect(gtk_builder_get_object(builder, "sensor_color"),
 223                          "color-set", G_CALLBACK(on_color_set), cbdata);
 224
 225         g_signal_connect(gtk_builder_get_object(builder, "sensor_alarm"),
 226                          "toggled", G_CALLBACK(on_alarm_toggled), cbdata);
 227
 228         g_signal_connect(gtk_builder_get_object(builder, "sensor_temp_limit"),
 229                          "value-changed", G_CALLBACK(on_temp_limit_changed),
 230                          cbdata);
 231 }
 232
 233 static void
 234 update_pref(struct psensor *s,
 235             struct sensor_pref **prefs,
 236             struct config *cfg,
 237             GtkBuilder *builder)
 238 {
 239         GtkLabel *w_id, *w_type, *w_temp_unit;
 240         GtkEntry *w_name;
 241         GtkToggleButton *w_draw, *w_alarm;
 242         GtkColorButton *w_color;
 243         GtkSpinButton *w_temp_limit;
 244         GdkColor *color;
 245         struct sensor_pref *p = sensor_pref_get(prefs, s);
 246         int use_celcius;
 247
 248         w_id = GTK_LABEL(gtk_builder_get_object(builder, "sensor_id"));
 249         gtk_label_set_text(w_id, s->id);
 250
 251         w_type = GTK_LABEL(gtk_builder_get_object(builder, "sensor_type"));
 252         gtk_label_set_text(w_type, psensor_type_to_str(s->type));
 253
 254         w_name = GTK_ENTRY(gtk_builder_get_object(builder, "sensor_name"));
 255         gtk_entry_set_text(w_name, p->name);
 256
 257         w_draw = GTK_TOGGLE_BUTTON(gtk_builder_get_object(builder,
 258                                                           "sensor_draw"));
 259         gtk_toggle_button_set_active(w_draw, p->enabled);
 260
 261         color = color_to_gdkcolor(p->color);
 262         w_color = GTK_COLOR_BUTTON(gtk_builder_get_object(builder,
 263                                                           "sensor_color"));
 264         gtk_color_button_set_color(w_color, color);
 265
 266         w_alarm = GTK_TOGGLE_BUTTON(gtk_builder_get_object(builder,
 267                                                            "sensor_alarm"));
 268         w_temp_limit
 269                 = GTK_SPIN_BUTTON(gtk_builder_get_object(builder,
 270                                                          "sensor_temp_limit"));
 271
 272         w_temp_unit
 273                 = GTK_LABEL(gtk_builder_get_object(builder,
 274                                                    "sensor_temp_unit"));
 275
 276         use_celcius = cfg->temperature_unit == CELCIUS ? 1 : 0;
 277         gtk_label_set_text(w_temp_unit,
 278                            psensor_type_to_unit_str(s->type,
 279                                                     use_celcius));
 280
 281         if (is_temp_type(s->type)) {
 282                 gtk_toggle_button_set_active(w_alarm, p->alarm_enabled);
 283                 gtk_spin_button_set_value(w_temp_limit, p->alarm_limit);
 284                 gtk_widget_set_sensitive(GTK_WIDGET(w_alarm), TRUE);
 285                 gtk_widget_set_sensitive(GTK_WIDGET(w_temp_limit), TRUE);
 286         } else {
 287                 gtk_toggle_button_set_active(w_alarm, 0);
 288                 gtk_spin_button_set_value(w_temp_limit, 0);
 289                 gtk_widget_set_sensitive(GTK_WIDGET(w_alarm), FALSE);
 290                 gtk_widget_set_sensitive(GTK_WIDGET(w_temp_limit), FALSE);
 291         }
 292 }
 293
 294 static void on_changed(GtkTreeSelection *selection, gpointer data)
 295 {
 296         GtkTreeModel *model;
 297         GtkTreeIter iter;
 298         struct cb_data *cbdata = data;
 299         struct ui_psensor *ui = cbdata->ui;
 300
 301         if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
 302                 GtkTreePath *p = gtk_tree_model_get_path(model, &iter);
 303                 gint *indices = gtk_tree_path_get_indices(p);
 304                 struct psensor *s = *(ui->sensors + *indices);
 305
 306                 update_pref(s,
 307                             cbdata->prefs,
 308                             ui->config,
 309                             cbdata->builder);
 310
 311                 gtk_tree_path_free(p);
 312         }
 313 }
 314
 315 static void
 316 select_sensor(struct psensor *s, struct psensor **sensors, GtkTreeView *tree)
 317 {
 318         struct psensor **s_cur = sensors;
 319         int i = 0;
 320         GtkTreePath *p = NULL;
 321
 322         while (*s_cur) {
 323                 if (s == *s_cur) {
 324                         p = gtk_tree_path_new_from_indices(i, -1);
 325                         break;
 326                 }
 327
 328                 i++;
 329                 s_cur++;
 330         }
 331
 332         if (p) {
 333                 GtkTreeSelection *s = gtk_tree_view_get_selection(tree);
 334
 335                 gtk_tree_selection_select_path(s, p);
 336                 gtk_tree_path_free(p);
 337         }
 338 }
 339
 340 static void
 341 apply_prefs(struct sensor_pref **prefs,
 342             struct psensor **sensors,
 343             struct config *cfg)
 344 {
 345         int n = psensor_list_size(sensors);
 346         int i;
 347
 348         for (i = 0; i < n; i++) {
 349                 struct psensor *s = sensors[i];
 350                 struct sensor_pref *p = prefs[i];
 351
 352                 if (strcmp(p->name, s->name)) {
 353                         free(s->name);
 354                         s->name = strdup(p->name);
 355                         config_set_sensor_name(s->id, s->name);
 356                 }
 357
 358                 if (s->enabled != p->enabled) {
 359                         s->enabled = p->enabled;
 360                         config_set_sensor_enabled(s->id, s->enabled);
 361                 }
 362
 363                 if (cfg->temperature_unit == CELCIUS)
 364                         s->alarm_limit = p->alarm_limit;
 365                 else
 366                         s->alarm_limit = fahrenheit_to_celcius
 367                                 (p->alarm_limit);
 368
 369                 config_set_sensor_alarm_limit(s->id,
 370                                               s->alarm_limit);
 371
 372                 if (s->alarm_enabled != p->alarm_enabled) {
 373                         s->alarm_enabled = p->alarm_enabled;
 374                         config_set_sensor_alarm_enabled(s->id,
 375                                                         s->alarm_enabled);
 376                 }
 377
 378                 color_set(s->color,
 379                           p->color->red, p->color->green, p->color->blue);
 380                 config_set_sensor_color(s->id, s->color);
 381         }
 382 }
 383
 384 void ui_sensorpref_dialog_run(struct psensor *sensor, struct ui_psensor *ui)
 385 {
 386         GtkDialog *diag;
 387         gint result;
 388         GtkBuilder *builder;
 389         GError *error = NULL;
 390         GtkTreeView *w_sensors_list;
 391         guint ok;
 392         GtkCellRenderer *renderer;
 393         GtkListStore *store;
 394         struct psensor **s_cur;
 395         GtkTreeSelection *selection;
 396         struct cb_data cbdata;
 397
 398         cbdata.ui = ui;
 399         cbdata.prefs = sensor_pref_list_new(ui->sensors,
 400                                             ui->config);
 401
 402         builder = gtk_builder_new();
 403         cbdata.builder = builder;
 404
 405         ok = gtk_builder_add_from_file
 406                 (builder,
 407                  PACKAGE_DATA_DIR G_DIR_SEPARATOR_S "sensor-edit.glade",
 408                  &error);
 409
 410         if (!ok) {
 411                 log_printf(LOG_ERR, error->message);
 412                 g_error_free(error);
 413                 return ;
 414         }
 415
 416         update_pref(sensor, cbdata.prefs, ui->config, builder);
 417         connect_signals(builder, &cbdata);
 418
 419         w_sensors_list
 420                 = GTK_TREE_VIEW(gtk_builder_get_object(builder,
 421                                                        "sensors_list"));
 422
 423         renderer = gtk_cell_renderer_text_new();
 424         gtk_tree_view_insert_column_with_attributes(w_sensors_list,
 425                                                     -1,
 426                                                     _("Sensor Name"),
 427                                                     renderer,
 428                                                     "text", 0, NULL);
 429
 430         store = GTK_LIST_STORE(gtk_tree_view_get_model(w_sensors_list));
 431
 432         s_cur = ui->sensors;
 433         while (*s_cur) {
 434                 GtkTreeIter iter;
 435                 struct psensor *s = *s_cur;
 436
 437                 gtk_list_store_append(store, &iter);
 438                 gtk_list_store_set(store, &iter, 0, s->name, -1);
 439
 440                 s_cur++;
 441         }
 442
 443         selection = gtk_tree_view_get_selection(w_sensors_list);
 444         g_signal_connect(selection, "changed", G_CALLBACK(on_changed), &cbdata);
 445         select_sensor(sensor, ui->sensors, w_sensors_list);
 446
 447         diag = GTK_DIALOG(gtk_builder_get_object(builder, "dialog1"));
 448         result = gtk_dialog_run(diag);
 449
 450         if (result == GTK_RESPONSE_ACCEPT) {
 451                 apply_prefs(cbdata.prefs, ui->sensors, ui->config);
 452                 ui_sensorlist_update_sensors_preferences(ui);
 453         }
 454
 455         g_object_unref(G_OBJECT(builder));
 456
 457         gtk_widget_destroy(GTK_WIDGET(diag));
 458
 459         sensor_pref_list_free(cbdata.prefs);
 460 }