src/math-converter.c

   1 /*
   2  * Copyright (C) 2008-2011 Robert Ancell
   3  *
   4  * This program is free software: you can redistribute it and/or modify it under
   5  * the terms of the GNU General Public License as published by the Free Software
   6  * Foundation, either version 2 of the License, or (at your option) any later
   7  * version. See http://www.gnu.org/copyleft/gpl.html the full text of the
   8  * license.
   9  */
  10
  11 #include <glib/gi18n.h>
  12
  13 #include "math-converter.h"
  14 #include "unit-manager.h"
  15 #include "currency-manager.h"
  16
  17 enum {
  18     CHANGED,
  19     LAST_SIGNAL
  20 };
  21 static guint signals[LAST_SIGNAL] = { 0, };
  22
  23 struct MathConverterPrivate
  24 {
  25     MathEquation *equation;
  26
  27     gchar *category;
  28
  29     GtkWidget *from_combo;
  30     GtkWidget *to_combo;
  31
  32     GtkWidget *result_label;
  33 };
  34
  35
  36 G_DEFINE_TYPE (MathConverter, math_converter, GTK_TYPE_HBOX);
  37
  38 static void display_changed_cb(MathEquation *equation, GParamSpec *spec, MathConverter *converter);
  39 static void update_from_model(MathConverter *converter);
  40
  41
  42 MathConverter *
  43 math_converter_new(MathEquation *equation)
  44 {
  45     MathConverter *converter = g_object_new(math_converter_get_type(), NULL);
  46     converter->priv->equation = g_object_ref(equation);
  47     g_signal_connect(converter->priv->equation, "notify::display", G_CALLBACK(display_changed_cb), converter);
  48     update_from_model(converter);
  49     return converter;
  50 }
  51
  52
  53 static gboolean
  54 convert_equation(MathConverter *converter, const MPNumber *x, MPNumber *z)
  55 {
  56     GtkTreeIter from_iter, to_iter;
  57     UnitCategory *category = NULL;
  58     Unit *source_unit = NULL, *target_unit = NULL;
  59     gboolean result;
  60
  61     if (!gtk_combo_box_get_active_iter(GTK_COMBO_BOX(converter->priv->from_combo), &from_iter) ||
  62         !gtk_combo_box_get_active_iter(GTK_COMBO_BOX(converter->priv->to_combo), &to_iter))
  63         return FALSE;
  64
  65     gtk_tree_model_get(gtk_combo_box_get_model(GTK_COMBO_BOX(converter->priv->from_combo)), &from_iter, 1, &category, 2, &source_unit, -1);
  66     gtk_tree_model_get(gtk_combo_box_get_model(GTK_COMBO_BOX(converter->priv->to_combo)), &to_iter, 2, &target_unit, -1);
  67
  68     result = unit_category_convert(category, x, source_unit, target_unit, z);
  69
  70     if (category)
  71         g_object_unref(category);
  72     if (source_unit)
  73         g_object_unref(source_unit);
  74     if (target_unit)
  75         g_object_unref(target_unit);
  76
  77     return result;
  78 }
  79
  80
  81 static void
  82 update_result_label(MathConverter *converter)
  83 {
  84     MPNumber x, z;
  85     gboolean enabled;
  86
  87     if (!converter->priv->result_label)
  88         return;
  89
  90     if (math_equation_get_number(converter->priv->equation, &x))
  91         enabled = convert_equation(converter, &x, &z);
  92     else
  93         enabled = FALSE;
  94
  95     gtk_widget_set_sensitive(converter->priv->result_label, enabled);
  96     if (enabled) {
  97         gchar *source_text, *target_text, *label;
  98         Unit *source_unit, *target_unit;
  99
 100         math_converter_get_conversion(converter, &source_unit, &target_unit);
 101
 102         source_text = unit_format(source_unit, &x);
 103         target_text = unit_format(target_unit, &z);
 104         label = g_strdup_printf("%s = %s", source_text, target_text);
 105         gtk_label_set_text(GTK_LABEL(converter->priv->result_label), label);
 106
 107         g_free(source_text);
 108         g_free(target_text);
 109         g_free(label);
 110
 111         g_object_unref(source_unit);
 112         g_object_unref(target_unit);
 113     }
 114 }
 115
 116
 117 static void
 118 display_changed_cb(MathEquation *equation, GParamSpec *spec, MathConverter *converter)
 119 {
 120     update_result_label(converter);
 121 }
 122
 123
 124 static void
 125 update_from_model(MathConverter *converter)
 126 {
 127     GtkTreeStore *from_model;
 128
 129     from_model = gtk_tree_store_new(3, G_TYPE_STRING, G_TYPE_OBJECT, G_TYPE_OBJECT);
 130
 131     if (converter->priv->category == NULL) {
 132         const GList *categories, *iter;
 133
 134         categories = unit_manager_get_categories(unit_manager_get_default());
 135         for (iter = categories; iter; iter = iter->next) {
 136             UnitCategory *category = iter->data;
 137             GtkTreeIter parent;
 138             const GList *unit_iter;
 139
 140             gtk_tree_store_append(from_model, &parent, NULL);
 141             gtk_tree_store_set(from_model, &parent, 0, unit_category_get_display_name(category), 1, category, -1);
 142
 143             for (unit_iter = unit_category_get_units(category); unit_iter; unit_iter = unit_iter->next) {
 144                 Unit *unit = unit_iter->data;
 145                 GtkTreeIter iter;
 146
 147                 gtk_tree_store_append(from_model, &iter, &parent);
 148                 gtk_tree_store_set(from_model, &iter, 0, unit_get_display_name(unit), 1, category, 2, unit, -1);
 149             }
 150         }
 151     }
 152     else {
 153         UnitCategory *category;
 154         const GList *unit_iter;
 155
 156         category = unit_manager_get_category(unit_manager_get_default(), converter->priv->category);
 157         for (unit_iter = unit_category_get_units(category); unit_iter; unit_iter = unit_iter->next) {
 158             Unit *unit = unit_iter->data;
 159             GtkTreeIter iter;
 160
 161             gtk_tree_store_append(from_model, &iter, NULL);
 162             gtk_tree_store_set(from_model, &iter, 0, unit_get_display_name(unit), 1, category, 2, unit, -1);
 163         }
 164     }
 165
 166     gtk_combo_box_set_model(GTK_COMBO_BOX(converter->priv->from_combo), GTK_TREE_MODEL(from_model));
 167 }
 168
 169
 170 void
 171 math_converter_set_category(MathConverter *converter, const gchar *category)
 172 {
 173     g_return_if_fail (converter != NULL);
 174
 175     if (category == NULL && converter->priv->category == NULL)
 176         return;
 177     if (category != NULL && converter->priv->category != NULL && strcmp(category, converter->priv->category) == 0)
 178         return;
 179
 180     g_free(converter->priv->category);
 181     converter->priv->category = g_strdup(category);
 182
 183     update_from_model(converter);
 184 }
 185
 186
 187 const gchar *
 188 math_converter_get_category(MathConverter *converter)
 189 {
 190     g_return_val_if_fail (converter != NULL, NULL);
 191     return converter->priv->category;
 192 }
 193
 194
 195 static gboolean
 196 iter_is_unit(GtkTreeModel *model, GtkTreeIter *iter, Unit *unit)
 197 {
 198     Unit *u;
 199
 200     gtk_tree_model_get(model, iter, 2, &u, -1);
 201
 202     if (!u)
 203         return FALSE;
 204
 205     g_object_unref(u);
 206     if (u == unit)
 207         return TRUE;
 208
 209     return FALSE;
 210 }
 211
 212
 213 static gboolean
 214 set_active_unit(GtkComboBox *combo, GtkTreeIter *iter, Unit *unit)
 215 {
 216     GtkTreeModel *model;
 217     GtkTreeIter child_iter;
 218
 219     model = gtk_combo_box_get_model(combo);
 220
 221     if (iter && iter_is_unit(model, iter, unit)) {
 222         gtk_combo_box_set_active_iter(combo, iter);
 223         return TRUE;
 224     }
 225
 226     if (!gtk_tree_model_iter_children(model, &child_iter, iter))
 227         return FALSE;
 228
 229     do {
 230         if (set_active_unit(combo, &child_iter, unit))
 231             return TRUE;
 232     } while (gtk_tree_model_iter_next(model, &child_iter));
 233
 234     return FALSE;
 235 }
 236
 237
 238 void
 239 math_converter_set_conversion(MathConverter *converter, /*const gchar *category,*/ const gchar *unit_a, const gchar *unit_b)
 240 {
 241     Unit *ua;
 242     Unit *ub;
 243
 244     g_return_if_fail (converter != NULL);
 245     g_return_if_fail (unit_a != NULL);
 246     g_return_if_fail (unit_b != NULL);
 247
 248     ua = unit_manager_get_unit_by_name(unit_manager_get_default(), unit_a);
 249     ub = unit_manager_get_unit_by_name(unit_manager_get_default(), unit_b);
 250     if (!ua || !ub)
 251     {
 252         GtkTreeModel *model;
 253         GtkTreeIter iter;
 254
 255         /* Select the first unit */
 256         model = gtk_combo_box_get_model(GTK_COMBO_BOX(converter->priv->from_combo));
 257         if (gtk_tree_model_get_iter_first(model, &iter)) {
 258             GtkTreeIter child_iter;
 259             while (gtk_tree_model_iter_children(model, &child_iter, &iter))
 260                 iter = child_iter;
 261             gtk_combo_box_set_active_iter(GTK_COMBO_BOX(converter->priv->from_combo), &iter);
 262         }
 263         return;
 264     }
 265
 266     set_active_unit(GTK_COMBO_BOX(converter->priv->from_combo), NULL, ua);
 267     set_active_unit(GTK_COMBO_BOX(converter->priv->to_combo), NULL, ub);
 268 }
 269
 270
 271 void
 272 math_converter_get_conversion(MathConverter *converter, Unit **from_unit, Unit **to_unit)
 273 {
 274     GtkTreeIter from_iter, to_iter;
 275
 276     g_return_if_fail (converter != NULL);
 277     g_return_if_fail (from_unit != NULL);
 278     g_return_if_fail (to_unit != NULL);
 279
 280     gtk_combo_box_get_active_iter(GTK_COMBO_BOX(converter->priv->from_combo), &from_iter);
 281     gtk_combo_box_get_active_iter(GTK_COMBO_BOX(converter->priv->to_combo), &to_iter);
 282
 283     gtk_tree_model_get(gtk_combo_box_get_model(GTK_COMBO_BOX(converter->priv->from_combo)), &from_iter, 2, from_unit, -1);
 284     gtk_tree_model_get(gtk_combo_box_get_model(GTK_COMBO_BOX(converter->priv->to_combo)), &to_iter, 2, to_unit, -1);
 285 }
 286
 287
 288 static void
 289 math_converter_class_init(MathConverterClass *klass)
 290 {
 291     g_type_class_add_private(klass, sizeof(MathConverterPrivate));
 292
 293     signals[CHANGED] =
 294         g_signal_new("changed",
 295                      G_TYPE_FROM_CLASS (klass),
 296                      G_SIGNAL_RUN_LAST,
 297                      G_STRUCT_OFFSET (MathConverterClass, changed),
 298                      NULL, NULL,
 299                      g_cclosure_marshal_VOID__VOID,
 300                      G_TYPE_NONE, 0);
 301 }
 302
 303
 304 static void
 305 from_combobox_changed_cb(GtkWidget *combo, MathConverter *converter)
 306 {
 307     GtkTreeModel *model;
 308     GtkTreeIter iter;
 309     UnitCategory *category;
 310     Unit *unit;
 311     const GList *unit_iter;
 312
 313     model = gtk_combo_box_get_model(GTK_COMBO_BOX(combo));
 314     if (!gtk_combo_box_get_active_iter(GTK_COMBO_BOX(combo), &iter))
 315         return;
 316     gtk_tree_model_get(model, &iter, 1, &category, 2, &unit, -1);
 317
 318     /* Set the to combobox to be the list of units can be converted to */
 319     model = GTK_TREE_MODEL(gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_OBJECT, G_TYPE_OBJECT));
 320     for (unit_iter = unit_category_get_units(category); unit_iter; unit_iter = unit_iter->next) {
 321         Unit *u = unit_iter->data;
 322         if (u == unit)
 323             continue;
 324         gtk_list_store_append(GTK_LIST_STORE(model), &iter);
 325         gtk_list_store_set(GTK_LIST_STORE(model), &iter, 0, unit_get_display_name(u), 1, category, 2, u, -1);
 326     }
 327     gtk_combo_box_set_model(GTK_COMBO_BOX(converter->priv->to_combo), model);
 328
 329     /* Select the first possible unit */
 330     gtk_combo_box_set_active(GTK_COMBO_BOX(converter->priv->to_combo), 0);
 331
 332     g_object_unref(category);
 333     g_object_unref(unit);
 334 }
 335
 336
 337 static void
 338 to_combobox_changed_cb(GtkWidget *combo, MathConverter *converter)
 339 {
 340     /* Conversion must have changed */
 341     update_result_label(converter);
 342
 343     g_signal_emit(converter, signals[CHANGED], 0);
 344 }
 345
 346
 347 static void
 348 from_cell_data_func(GtkCellLayout   *cell_layout,
 349                     GtkCellRenderer *cell,
 350                     GtkTreeModel    *tree_model,
 351                     GtkTreeIter     *iter,
 352                     gpointer         data)
 353 {
 354     g_object_set(cell, "sensitive", !gtk_tree_model_iter_has_child(tree_model, iter), NULL);
 355 }
 356
 357
 358 static void
 359 currency_updated_cb(CurrencyManager *manager, MathConverter *converter)
 360 {
 361     update_result_label(converter);
 362 }
 363
 364 static void
 365 swap_button_clicked_cb(GtkButton *button, MathConverter *converter)
 366 {
 367     Unit *from_unit, *to_unit;
 368     MPNumber x, z;
 369
 370     if (math_equation_get_number(converter->priv->equation, &x) &&
 371         convert_equation(converter, &x, &z))
 372         math_equation_set_number(converter->priv->equation, &z);
 373
 374     math_converter_get_conversion(converter, &from_unit, &to_unit);
 375     set_active_unit(GTK_COMBO_BOX(converter->priv->from_combo), NULL, to_unit);
 376     set_active_unit(GTK_COMBO_BOX(converter->priv->to_combo), NULL, from_unit);
 377
 378     update_result_label(converter);
 379
 380     g_object_unref(from_unit);
 381     g_object_unref(to_unit);
 382 }
 383
 384 static void
 385 math_converter_init(MathConverter *converter)
 386 {
 387     GtkWidget *hbox, *label, *swap_button;
 388     GtkCellRenderer *renderer;
 389
 390     converter->priv = G_TYPE_INSTANCE_GET_PRIVATE(converter, math_converter_get_type(), MathConverterPrivate);
 391
 392     gtk_box_set_spacing(GTK_BOX(converter), 6);
 393
 394     hbox = gtk_hbox_new(FALSE, 0);
 395     gtk_widget_show(hbox);
 396     gtk_box_pack_start(GTK_BOX(converter), hbox, FALSE, TRUE, 0);
 397
 398     converter->priv->from_combo = gtk_combo_box_new ();
 399
 400     renderer = gtk_cell_renderer_text_new();
 401     gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(converter->priv->from_combo), renderer, TRUE);
 402     gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(converter->priv->from_combo), renderer, "text", 0);
 403     gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(converter->priv->from_combo),
 404                                        renderer,
 405                                        from_cell_data_func,
 406                                        NULL, NULL);
 407     g_signal_connect(converter->priv->from_combo, "changed", G_CALLBACK(from_combobox_changed_cb), converter);
 408     gtk_widget_show(converter->priv->from_combo);
 409     gtk_box_pack_start(GTK_BOX(hbox), converter->priv->from_combo, FALSE, TRUE, 0);
 410
 411     label = gtk_label_new(/* Label that is displayed between the two conversion combo boxes, e.g. "[degrees] in [radians]" */
 412                           _(" in "));
 413     gtk_widget_show(label);
 414     gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 5);
 415
 416     converter->priv->to_combo = gtk_combo_box_new();
 417     renderer = gtk_cell_renderer_text_new();
 418     gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(converter->priv->to_combo), renderer, TRUE);
 419     gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(converter->priv->to_combo), renderer, "text", 0);
 420     g_signal_connect(converter->priv->to_combo, "changed", G_CALLBACK(to_combobox_changed_cb), converter);
 421     gtk_widget_show(converter->priv->to_combo);
 422     gtk_box_pack_start(GTK_BOX(hbox), converter->priv->to_combo, FALSE, TRUE, 0);
 423
 424     swap_button = gtk_button_new_with_label ("⇆");
 425     gtk_widget_set_tooltip_text (swap_button,
 426                                  /* Tooltip for swap conversion button */
 427                                  _("Switch conversion units"));
 428     gtk_button_set_relief (GTK_BUTTON (swap_button), GTK_RELIEF_NONE);
 429     g_signal_connect (swap_button, "clicked", G_CALLBACK (swap_button_clicked_cb), converter);
 430     gtk_widget_show(swap_button);
 431     gtk_box_pack_start(GTK_BOX(hbox), swap_button, FALSE, TRUE, 0);
 432
 433     converter->priv->result_label = gtk_label_new("");
 434     gtk_misc_set_alignment(GTK_MISC(converter->priv->result_label), 1.0, 0.5);
 435     gtk_widget_set_sensitive(converter->priv->result_label, FALSE);
 436     gtk_widget_show(converter->priv->result_label);
 437     gtk_box_pack_start(GTK_BOX(converter), converter->priv->result_label, TRUE, TRUE, 0);
 438
 439     g_signal_connect(currency_manager_get_default(), "updated", G_CALLBACK(currency_updated_cb), converter);
 440 }