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