1 files changed, 627 insertions, 375 deletions
diff --git a/src/math-equation.c b/src/math-equation.c
index ef86221..5bcae64 100644
--- a/src/math-equation.c
+++ b/src/math-equation.c
@@ -1,20 +1,12 @@
-/* Copyright (c) 1987-2008 Sun Microsystems, Inc. All Rights Reserved.
- * Copyright (c) 2008-2009 Robert Ancell
+/*
+ * Copyright (C) 1987-2008 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright (C) 2008-2011 Robert Ancell
 *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2, or (at your option)
- * any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License as published by the Free Software
+ * Foundation, either version 2 of the License, or (at your option) any later
+ * version. See http://www.gnu.org/copyleft/gpl.html the full text of the
+ * license.
 */
 
 #include <stdlib.h>
@@ -24,14 +16,15 @@
 #include <math.h>
 #include <errno.h>
 #include <glib.h>
-#include <langinfo.h>
-#include <locale.h>
+#include <glib/gi18n.h>
 
 #include "math-equation.h"
 
 #include "mp.h"
 #include "mp-equation.h"
-#include "currency.h"
+#include "mp-serializer.h"
+#include "mp-enums.h"
+#include "unit-manager.h"
 
 
 enum {
@@ -48,7 +41,10 @@ enum {
 PROP_WORD_SIZE,
 PROP_ANGLE_UNITS,
 PROP_SOURCE_CURRENCY,
- PROP_TARGET_CURRENCY
+ PROP_TARGET_CURRENCY,
+ PROP_SOURCE_UNITS,
+ PROP_TARGET_UNITS, 
+ PROP_SERIALIZER
 };
 
 static GType number_mode_type, number_format_type, angle_unit_type;
@@ -71,44 +67,49 @@ struct MathEquationPrivate
 {
 GtkTextTag *ans_tag;
 
- gint show_tsep; /* Set if the thousands separator should be shown. */
- gint show_zeroes; /* Set if trailing zeroes should be shown. */
- DisplayFormat format; /* Number display mode. */
- gint accuracy; /* Number of digits to show */
 gint word_size; /* Word size in bits */
 MPAngleUnit angle_units; /* Units for trigonometric functions */
 char *source_currency;
 char *target_currency;
- gint base; /* Numeric base */
+ char *source_units;
+ char *target_units;
 NumberMode number_mode; /* ??? */
 gboolean can_super_minus; /* TRUE if entering minus can generate a superscript minus */
 
- const char *digits[16]; /* Localized digit values */
- const char *radix; /* Locale specific radix string. */
- const char *tsep; /* Locale specific thousands separator. */
- gint tsep_count; /* Number of digits between separator. */
+ gunichar digits[16]; /* Localized digits */
 
 GtkTextMark *ans_start, *ans_end;
 
 MathEquationState state; /* Equation state */
- GList *undo_stack; /* History of expression mode states */
+ GList *undo_stack; /* History of expression mode states */
 GList *redo_stack;
 gboolean in_undo_operation;
-
+ 
 gboolean in_reformat;
 
 gboolean in_delete;
 
+ gboolean in_solve;
+
 MathVariables *variables;
+ MpSerializer *serializer;
+
+ GAsyncQueue *queue;
 };
 
+typedef struct {
+ MPNumber *number_result;
+ gchar *text_result;
+ gchar *error;
+} SolveData;
+
 G_DEFINE_TYPE (MathEquation, math_equation, GTK_TYPE_TEXT_BUFFER);
 
 
 MathEquation *
 math_equation_new()
 {
- return g_object_new (math_equation_get_type(), NULL);
+ return g_object_new(math_equation_get_type(), NULL);
 }
 
 
@@ -123,7 +124,7 @@ static void
 get_ans_offsets(MathEquation *equation, gint *start, gint *end)
 {
 GtkTextIter iter;
-
+ 
 if (!equation->priv->ans_start) {
 *start = *end = -1;
 return;
@@ -143,13 +144,13 @@ reformat_ans(MathEquation *equation)
 return;
 
 gchar *orig_ans_text;
- gchar ans_text[MAX_DIGITS];
+ gchar *ans_text;
 GtkTextIter ans_start, ans_end;
 
 gtk_text_buffer_get_iter_at_mark(GTK_TEXT_BUFFER(equation), &ans_start, equation->priv->ans_start);
 gtk_text_buffer_get_iter_at_mark(GTK_TEXT_BUFFER(equation), &ans_end, equation->priv->ans_end);
 orig_ans_text = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(equation), &ans_start, &ans_end, FALSE);
- display_make_number(equation, ans_text, MAX_DIGITS, &equation->priv->state.ans);
+ ans_text = mp_serializer_to_string(equation->priv->serializer, &equation->priv->state.ans);
 if (strcmp(orig_ans_text, ans_text) != 0) {
 gint start;
 
@@ -171,166 +172,122 @@ reformat_ans(MathEquation *equation)
 gtk_text_buffer_get_iter_at_mark(GTK_TEXT_BUFFER(equation), &ans_start, equation->priv->ans_start);
 gtk_text_buffer_get_iter_at_mark(GTK_TEXT_BUFFER(equation), &ans_end, equation->priv->ans_end);
 g_free(orig_ans_text);
+ g_free(ans_text);
+}
+
+
+static gint
+count_digits(MathEquation *equation, const gchar *text)
+{
+ const gchar *read_iter;
+ gint count = 0;
+
+ read_iter = text;
+ while (*read_iter != '\0') {
+ if (!g_unichar_isdigit(g_utf8_get_char(read_iter)))
+ return count;
+
+ read_iter = g_utf8_next_char(read_iter);
+
+ /* Allow a thousands separator between digits follow a digit */
+ if (g_utf8_get_char(read_iter) == mp_serializer_get_thousands_separator(equation->priv->serializer)) {
+ read_iter = g_utf8_next_char(read_iter);
+ if (!g_unichar_isdigit(g_utf8_get_char(read_iter)))
+ return count;
+ }
+
+ count++;
+ }
+
+ return count;
 }
 
 
-/* NOTE: Not efficent but easy to write */
-// FIXME: This is just a lexer - use the same lexer as the solver
 static void
-reformat_base(MathEquation *equation, gint old_base)
+reformat_separators(MathEquation *equation)
 {
- gunichar sub_zero, sub_nine;
 gchar *text, *read_iter;
- gboolean in_number = FALSE, have_radix = FALSE;
- gint offset = 0, offset_step = 0, max_digit = 0, base = -1, base_offset = 0;
 gint ans_start, ans_end;
+ gint offset, digit_offset = 0;
+ gboolean in_number = FALSE, in_radix = FALSE, last_is_tsep = FALSE;
 
- if (equation->priv->base == old_base)
- return;
-
- sub_zero = g_utf8_get_char("₀");
- sub_nine = g_utf8_get_char("₉");
+ equation->priv->in_undo_operation = TRUE;
+ equation->priv->in_reformat = TRUE;
 
- read_iter = text = math_equation_get_display(equation);
+ text = math_equation_get_display(equation);
 get_ans_offsets(equation, &ans_start, &ans_end);
- while (TRUE) {
+ for (read_iter = text, offset = 0; *read_iter != '\0'; read_iter = g_utf8_next_char(read_iter), offset++) {
 gunichar c;
- gint digit = -1, sub_digit = -1;
+ gboolean expect_tsep;
 
 /* See what digit this character is */
 c = g_utf8_get_char(read_iter);
- if (c >= sub_zero && c <= sub_nine)
- sub_digit = c - sub_zero;
- else if (c >= 'a' && c <= 'z')
- digit = c - 'a';
- else if (c >= 'A' && c <= 'Z')
- digit = c - 'A';
- else
- digit = g_unichar_digit_value(c);
+
+ expect_tsep = math_equation_get_base(equation) == 10 &&
+ mp_serializer_get_show_thousands_separators(equation->priv->serializer) &&
+ in_number && !in_radix && !last_is_tsep &&
+ digit_offset > 0 && digit_offset % mp_serializer_get_thousands_separator_count(equation->priv->serializer) == 0;
+ last_is_tsep = FALSE;
 
 /* Don't mess with ans */
 if (offset >= ans_start && offset <= ans_end) {
- digit = -1;
- sub_digit = -1;
+ in_number = in_radix = FALSE;
+ continue;
 }
+ if (g_unichar_isdigit(c)) {
+ if (!in_number)
+ digit_offset = count_digits(equation, read_iter);
+ in_number = TRUE;
 
- if (in_number && digit >= 0) {
- if (digit > max_digit)
- max_digit = digit;
- }
- else if (in_number && sub_digit >= 0) {
- if (base < 0) {
- base_offset = offset;
- base = 0;
+ /* Expected a thousands separator between these digits - insert it */
+ if (expect_tsep) {
+ GtkTextIter iter;
+ gchar buffer[7];
+ gint len;
+
+ gtk_text_buffer_get_iter_at_offset(GTK_TEXT_BUFFER(equation), &iter, offset);
+ len = g_unichar_to_utf8(mp_serializer_get_thousands_separator(equation->priv->serializer), buffer);
+ buffer[len] = '\0';
+ gtk_text_buffer_insert(GTK_TEXT_BUFFER(equation), &iter, buffer, -1);
+ offset++;
+ last_is_tsep = TRUE;
 }
 
- base = base * 10 + sub_digit;
+ digit_offset--;
 }
- else if (in_number) {
- /* Allow one radix inside a number */
- if (!have_radix && base < 0 && strncmp(read_iter, equation->priv->radix, strlen(equation->priv->radix)) == 0) {
- have_radix = TRUE;
- read_iter += strlen(equation->priv->radix);
- offset += g_utf8_strlen(equation->priv->radix, -1);
- continue;
- }
-
- /* If had no base then insert it */
- if (base < 0) {
- GtkTextIter iter;
- gint multiplier = 1;
- gint b = old_base;
- const char *digits[] = {"₀", "₁", "₂", "₃", "₄", "₅", "₆", "₇", "₈", "₉"};
-
- equation->priv->in_undo_operation = TRUE;
- equation->priv->in_reformat = TRUE;
-
- while (b / multiplier != 0)
- multiplier *= 10;
- while (multiplier != 1) {
- int d;
- multiplier /= 10;
- d = b / multiplier;
- gtk_text_buffer_get_iter_at_offset(GTK_TEXT_BUFFER(equation), &iter, offset + offset_step);
- gtk_text_buffer_insert(GTK_TEXT_BUFFER(equation), &iter, digits[d], -1);
- offset_step++;
- b -= d * multiplier;
- }
-
- equation->priv->in_reformat = FALSE;
- equation->priv->in_undo_operation = FALSE;
- }
- /* Remove the base if the current value */
- else if (max_digit < base && base == equation->priv->base) {
+ else if (c == mp_serializer_get_radix(equation->priv->serializer)) {
+ in_number = in_radix = TRUE;
+ }
+ else if (c == mp_serializer_get_thousands_separator(equation->priv->serializer)) {
+ /* Didn't expect thousands separator - delete it */
+ if (!expect_tsep && in_number) {
 GtkTextIter start, end;
-
- equation->priv->in_undo_operation = TRUE;
- equation->priv->in_reformat = TRUE;
-
- gtk_text_buffer_get_iter_at_offset(GTK_TEXT_BUFFER(equation), &start, base_offset + offset_step);
- gtk_text_buffer_get_iter_at_offset(GTK_TEXT_BUFFER(equation), &end, offset + offset_step);
+ gtk_text_buffer_get_iter_at_offset(GTK_TEXT_BUFFER(equation), &start, offset);
+ gtk_text_buffer_get_iter_at_offset(GTK_TEXT_BUFFER(equation), &end, offset + 1);
 gtk_text_buffer_delete(GTK_TEXT_BUFFER(equation), &start, &end);
- offset_step -= offset - base_offset;
-
- equation->priv->in_reformat = FALSE;
- equation->priv->in_undo_operation = FALSE;
+ offset--;
 }
-
- in_number = FALSE;
+ else
+ last_is_tsep = TRUE; 
 }
- else if (digit >= 0) {
- in_number = TRUE;
- have_radix = FALSE;
- base = -1;
- max_digit = digit;
+ else {
+ in_number = in_radix = FALSE;
 }
-
- if (c == '\0')
- break;
-
- read_iter = g_utf8_next_char(read_iter);
- offset++;
 }
 
 g_free(text);
-}
-
-
-static void
-reformat_separators(MathEquation *equation)
-{
-#if 0
- gchar *text, *read_iter;
- gboolean in_number = FALSE, in_fraction = FALSE;
-
- text = math_equation_get_display(equation);
-
- /* Find numbers in display, and modify if necessary */
- read_iter = text;
- while(*read_iter != '\0') {
- gunichar c;
 
- c = g_utf8_get_char(read_iter);
-
- if (strncmp(read_iter, equation->priv->tsep, strlen(equation->priv->tsep)) == 0)
- ;
- read_iter = g_utf8_next_char(read_iter);
- }
-
- g_free(text);
-#endif
+ equation->priv->in_reformat = FALSE;
+ equation->priv->in_undo_operation = FALSE;
 }
 
 
 static void
-reformat_display(MathEquation *equation, gint old_base)
+reformat_display(MathEquation *equation)
 {
 /* Change ans */
 reformat_ans(equation);
 
- /* Add/remove base suffixes if have changed base */
- reformat_base(equation, old_base);
-
 /* Add/remove thousands separators */
 reformat_separators(equation);
 }
@@ -362,7 +319,7 @@ get_current_state(MathEquation *equation)
 state->can_super_minus = equation->priv->can_super_minus;
 state->entered_multiply = equation->priv->state.entered_multiply;
 state->status = g_strdup(equation->priv->state.status);
-
+ 
 return state;
 }
 
@@ -396,7 +353,7 @@ math_equation_push_undo_stack(MathEquation *equation)
 equation->priv->redo_stack = NULL;
 
 state = get_current_state(equation);
- equation->priv->undo_stack = g_list_prepend(equation->priv->undo_stack, state);
+ equation->priv->undo_stack = g_list_prepend(equation->priv->undo_stack, state); 
 }
 
 
@@ -425,7 +382,7 @@ static void
 apply_state(MathEquation *equation, MathEquationState *state)
 {
 GtkTextIter cursor;
-
+ 
 /* Disable undo detection */
 equation->priv->in_undo_operation = TRUE;
 
@@ -459,13 +416,15 @@ math_equation_copy(MathEquation *equation)
 {
 GtkTextIter start, end;
 gchar *text;
+ 
+ g_return_if_fail(equation != NULL);
 
 if (!gtk_text_buffer_get_selection_bounds(GTK_TEXT_BUFFER(equation), &start, &end))
 gtk_text_buffer_get_bounds(GTK_TEXT_BUFFER(equation), &start, &end);
 
 text = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(equation), &start, &end, FALSE);
 gtk_clipboard_set_text(gtk_clipboard_get(GDK_NONE), text, -1);
- g_free (text);
+ g_free(text);
 }
 
 
@@ -473,7 +432,6 @@ static void
 on_paste(GtkClipboard *clipboard, const gchar *text, gpointer data)
 {
 MathEquation *equation = data;
- 
 if (text != NULL)
 math_equation_insert(equation, text);
 }
@@ -482,6 +440,7 @@ on_paste(GtkClipboard *clipboard, const gchar *text, gpointer data)
 void
 math_equation_paste(MathEquation *equation)
 {
+ g_return_if_fail(equation != NULL);
 gtk_clipboard_request_text(gtk_clipboard_get(GDK_NONE), on_paste, equation);
 }
 
@@ -492,6 +451,8 @@ math_equation_undo(MathEquation *equation)
 GList *link;
 MathEquationState *state;
 
+ g_return_if_fail(equation != NULL);
+
 if (!equation->priv->undo_stack) {
 math_equation_set_status(equation,
 /* Error shown when trying to undo with no undo history */
@@ -517,6 +478,8 @@ math_equation_redo(MathEquation *equation)
 GList *link;
 MathEquationState *state;
 
+ g_return_if_fail(equation != NULL);
+
 if (!equation->priv->redo_stack) {
 math_equation_set_status(equation,
 /* Error shown when trying to redo with no redo history */
@@ -536,33 +499,25 @@ math_equation_redo(MathEquation *equation)
 }
 
 
-const gchar *
+gunichar
 math_equation_get_digit_text(MathEquation *equation, guint digit)
 {
- return equation->priv->digits[digit];
-}
-
-
-const gchar *
-math_equation_get_numeric_point_text(MathEquation *equation)
-{
- return equation->priv->radix;
-}
+ g_return_val_if_fail(equation != NULL, '?');
+ g_return_val_if_fail(digit < 16, '?');
 
-
-const gchar *math_equation_get_thousands_separator_text(MathEquation *equation)
-{
- return equation->priv->tsep;
+ return equation->priv->digits[digit];
 }
 
 
 void
 math_equation_set_accuracy(MathEquation *equation, gint accuracy)
 {
- if (equation->priv->accuracy == accuracy)
+ g_return_if_fail(equation != NULL);
+
+ if (mp_serializer_get_trailing_digits(equation->priv->serializer) == accuracy)
 return;
- equation->priv->accuracy = accuracy;
- reformat_display(equation, equation->priv->base);
+ mp_serializer_set_trailing_digits(equation->priv->serializer, accuracy);
+ reformat_display(equation);
 g_object_notify(G_OBJECT(equation), "accuracy");
 }
 
@@ -570,17 +525,22 @@ math_equation_set_accuracy(MathEquation *equation, gint accuracy)
 gint
 math_equation_get_accuracy(MathEquation *equation)
 {
- return equation->priv->accuracy;
+ g_return_val_if_fail(equation != NULL, 0);
+
+ return mp_serializer_get_trailing_digits(equation->priv->serializer);
 }
 
 
 void
 math_equation_set_show_thousands_separators(MathEquation *equation, gboolean visible)
 {
- if ((equation->priv->show_tsep && visible) || (!equation->priv->show_tsep && !visible))
+ g_return_if_fail(equation != NULL);
+
+ if (mp_serializer_get_show_thousands_separators(equation->priv->serializer) == visible)
 return;
- equation->priv->show_tsep = visible;
- reformat_display(equation, equation->priv->base);
+
+ mp_serializer_set_show_thousands_separators(equation->priv->serializer, visible);
+ reformat_display(equation);
 g_object_notify(G_OBJECT(equation), "show-thousands-separators");
 }
 
@@ -588,17 +548,21 @@ math_equation_set_show_thousands_separators(MathEquation *equation, gboolean vis
 gboolean
 math_equation_get_show_thousands_separators(MathEquation *equation)
 {
- return equation->priv->show_tsep;
+ g_return_val_if_fail(equation != NULL, FALSE);
+ return mp_serializer_get_show_thousands_separators(equation->priv->serializer);
 }
 
 
 void
 math_equation_set_show_trailing_zeroes(MathEquation *equation, gboolean visible)
 {
- if ((equation->priv->show_zeroes && visible) || (!equation->priv->show_zeroes && !visible))
+ g_return_if_fail(equation != NULL);
+
+ if (mp_serializer_get_show_trailing_zeroes(equation->priv->serializer) == visible)
 return;
- equation->priv->show_zeroes = visible;
- reformat_display(equation, equation->priv->base);
+
+ mp_serializer_set_show_trailing_zeroes(equation->priv->serializer, visible);
+ reformat_display(equation);
 g_object_notify(G_OBJECT(equation), "show-trailing-zeroes");
 }
 
@@ -606,40 +570,43 @@ math_equation_set_show_trailing_zeroes(MathEquation *equation, gboolean visible)
 gboolean
 math_equation_get_show_trailing_zeroes(MathEquation *equation)
 {
- return equation->priv->show_zeroes;
+ g_return_val_if_fail(equation != NULL, FALSE);
+ return mp_serializer_get_show_trailing_zeroes(equation->priv->serializer);
 }
 
 
 void
-math_equation_set_number_format(MathEquation *equation, DisplayFormat format)
+math_equation_set_number_format(MathEquation *equation, MpDisplayFormat format)
 {
- if (equation->priv->format == format)
+ g_return_if_fail(equation != NULL);
+
+ if (mp_serializer_get_number_format(equation->priv->serializer) == format)
 return;
 
- equation->priv->format = format;
- reformat_display(equation, equation->priv->base);
+ mp_serializer_set_number_format(equation->priv->serializer, format);
+ reformat_display(equation);
 g_object_notify(G_OBJECT(equation), "number-format");
 }
 
 
-DisplayFormat
+MpDisplayFormat
 math_equation_get_number_format(MathEquation *equation)
 {
- return equation->priv->format;
+ g_return_val_if_fail(equation != NULL, MP_DISPLAY_FORMAT_AUTOMATIC);
+ return mp_serializer_get_number_format(equation->priv->serializer);
 }
 
 
 void
 math_equation_set_base(MathEquation *equation, gint base)
 {
- gint old_base;
+ g_return_if_fail(equation != NULL);
 
- if (equation->priv->base == base)
+ if (mp_serializer_get_base(equation->priv->serializer) == base)
 return;
 
- old_base = equation->priv->base;
- equation->priv->base = base;
- reformat_display(equation, old_base);
+ mp_serializer_set_base(equation->priv->serializer, base);
+ reformat_display(equation);
 g_object_notify(G_OBJECT(equation), "base");
 }
 
@@ -647,15 +614,19 @@ math_equation_set_base(MathEquation *equation, gint base)
 gint
 math_equation_get_base(MathEquation *equation)
 {
- return equation->priv->base;
+ g_return_val_if_fail(equation != NULL, 10);
+ return mp_serializer_get_base(equation->priv->serializer);
 }
 
 
 void
 math_equation_set_word_size(MathEquation *equation, gint word_size)
 {
+ g_return_if_fail(equation != NULL);
+
 if (equation->priv->word_size == word_size)
 return;
+
 equation->priv->word_size = word_size;
 g_object_notify(G_OBJECT(equation), "word-size");
 }
@@ -664,6 +635,7 @@ math_equation_set_word_size(MathEquation *equation, gint word_size)
 gint
 math_equation_get_word_size(MathEquation *equation)
 {
+ g_return_val_if_fail(equation != NULL, 64);
 return equation->priv->word_size;
 }
 
@@ -671,8 +643,11 @@ math_equation_get_word_size(MathEquation *equation)
 void
 math_equation_set_angle_units(MathEquation *equation, MPAngleUnit angle_units)
 {
+ g_return_if_fail(equation != NULL);
+
 if (equation->priv->angle_units == angle_units)
 return;
+
 equation->priv->angle_units = angle_units;
 g_object_notify(G_OBJECT(equation), "angle-units");
 }
@@ -681,6 +656,7 @@ math_equation_set_angle_units(MathEquation *equation, MPAngleUnit angle_units)
 MPAngleUnit
 math_equation_get_angle_units(MathEquation *equation)
 {
+ g_return_val_if_fail(equation != NULL, MP_DEGREES);
 return equation->priv->angle_units;
 }
 
@@ -688,9 +664,8 @@ math_equation_get_angle_units(MathEquation *equation)
 void
 math_equation_set_source_currency(MathEquation *equation, const gchar *currency)
 {
- // FIXME: Pick based on locale
- if (!currency || currency[0] == '\0')
- currency = currency_names[0].short_name;
+ g_return_if_fail(equation != NULL);
+ g_return_if_fail(currency != NULL);
 
 if (strcmp(equation->priv->source_currency, currency) == 0)
 return;
@@ -699,9 +674,11 @@ math_equation_set_source_currency(MathEquation *equation, const gchar *currency)
 g_object_notify(G_OBJECT(equation), "source-currency");
 }
 
+
 const gchar *
 math_equation_get_source_currency(MathEquation *equation)
 {
+ g_return_val_if_fail(equation != NULL, NULL);
 return equation->priv->source_currency;
 }
 
@@ -709,9 +686,8 @@ math_equation_get_source_currency(MathEquation *equation)
 void
 math_equation_set_target_currency(MathEquation *equation, const gchar *currency)
 {
- // FIXME: Pick based on locale
- if (!currency || currency[0] == '\0')
- currency = currency_names[0].short_name;
+ g_return_if_fail(equation != NULL);
+ g_return_if_fail(currency != NULL);
 
 if (strcmp(equation->priv->target_currency, currency) == 0)
 return;
@@ -724,25 +700,75 @@ math_equation_set_target_currency(MathEquation *equation, const gchar *currency)
 const gchar *
 math_equation_get_target_currency(MathEquation *equation)
 {
+ g_return_val_if_fail(equation != NULL, NULL);
 return equation->priv->target_currency;
 }
 
 
 void
+math_equation_set_source_units(MathEquation *equation, const gchar *units)
+{
+ g_return_if_fail(equation != NULL);
+ g_return_if_fail(units != NULL);
+
+ if (strcmp(equation->priv->source_units, units) == 0)
+ return;
+
+ g_free(equation->priv->source_units);
+ equation->priv->source_units = g_strdup(units);
+ g_object_notify(G_OBJECT(equation), "source-units");
+}
+
+const gchar *
+math_equation_get_source_units(MathEquation *equation)
+{
+ g_return_val_if_fail(equation != NULL, NULL);
+ return equation->priv->source_units;
+}
+
+
+void
+math_equation_set_target_units(MathEquation *equation, const gchar *units)
+{
+ g_return_if_fail(equation != NULL);
+ g_return_if_fail(units != NULL);
+
+ if (strcmp(equation->priv->target_units, units) == 0)
+ return;
+
+ g_free(equation->priv->target_units);
+ equation->priv->target_units = g_strdup(units);
+ g_object_notify(G_OBJECT(equation), "target-units");
+}
+
+
+const gchar *
+math_equation_get_target_units(MathEquation *equation)
+{
+ g_return_val_if_fail(equation != NULL, NULL);
+ return equation->priv->target_units;
+}
+
+
+void
 math_equation_set_status(MathEquation *equation, const gchar *status)
 {
+ g_return_if_fail(equation != NULL);
+ g_return_if_fail(status != NULL);
+
 if (strcmp(equation->priv->state.status, status) == 0)
 return;
 
 g_free(equation->priv->state.status);
 equation->priv->state.status = g_strdup(status);
- g_object_notify(G_OBJECT(equation), "status");
+ g_object_notify(G_OBJECT(equation), "status"); 
 }
 
 
 const gchar *
 math_equation_get_status(MathEquation *equation)
 {
+ g_return_val_if_fail(equation != NULL, NULL);
 return equation->priv->state.status;
 }
 
@@ -750,6 +776,7 @@ math_equation_get_status(MathEquation *equation)
 gboolean
 math_equation_is_empty(MathEquation *equation)
 {
+ g_return_val_if_fail(equation != NULL, FALSE);
 return gtk_text_buffer_get_char_count(GTK_TEXT_BUFFER(equation)) == 0;
 }
 
@@ -759,6 +786,8 @@ math_equation_is_result(MathEquation *equation)
 {
 char *text;
 gboolean result;
+ 
+ g_return_val_if_fail(equation != NULL, FALSE);
 
 text = math_equation_get_equation(equation);
 result = strcmp(text, "ans") == 0;
@@ -773,6 +802,8 @@ math_equation_get_display(MathEquation *equation)
 {
 GtkTextIter start, end;
 
+ g_return_val_if_fail(equation != NULL, NULL);
+
 gtk_text_buffer_get_bounds(GTK_TEXT_BUFFER(equation), &start, &end);
 return gtk_text_buffer_get_text(GTK_TEXT_BUFFER(equation), &start, &end, FALSE);
 }
@@ -781,19 +812,54 @@ math_equation_get_display(MathEquation *equation)
 gchar *
 math_equation_get_equation(MathEquation *equation)
 {
- char *text, *t;
- gint ans_start, ans_end;
+ gchar *text;
+ GString *eq_text;
+ gint ans_start = -1, ans_end = -1, offset;
+ const gchar *read_iter;
+ gboolean last_is_digit = FALSE;
+
+ g_return_val_if_fail(equation != NULL, NULL);
 
 text = math_equation_get_display(equation);
+ eq_text = g_string_sized_new(strlen(text));
+
+ if (equation->priv->ans_start)
+ get_ans_offsets(equation, &ans_start, &ans_end);
 
- /* No ans to substitute */
- if(!equation->priv->ans_start)
- return text;
+ for (read_iter = text, offset = 0; *read_iter != '\0'; read_iter = g_utf8_next_char(read_iter), offset++) {
+ gunichar c;
+ gboolean is_digit, next_is_digit;
 
- get_ans_offsets(equation, &ans_start, &ans_end);
- t = g_strdup_printf("%.*sans%s", (int)(g_utf8_offset_to_pointer(text, ans_start) - text), text, g_utf8_offset_to_pointer(text, ans_end));
+ c = g_utf8_get_char(read_iter);
+ is_digit = g_unichar_isdigit(c);
+ next_is_digit = g_unichar_isdigit(g_utf8_get_char(g_utf8_next_char(read_iter)));
+
+ /* Replace ans text with variable */
+ if (offset == ans_start) { 
+ g_string_append(eq_text, "ans");
+ read_iter = g_utf8_offset_to_pointer(read_iter, ans_end - ans_start - 1);
+ offset += ans_end - ans_start - 1;
+ is_digit = FALSE;
+ continue;
+ }
+
+ /* Ignore thousands separators */
+ if (c == mp_serializer_get_thousands_separator(equation->priv->serializer) && last_is_digit && next_is_digit)
+ ;
+ /* Substitute radix character */
+ else if (c == mp_serializer_get_radix(equation->priv->serializer) && (last_is_digit || next_is_digit))
+ g_string_append_unichar(eq_text, '.');
+ else
+ g_string_append_unichar(eq_text, c);
+
+ last_is_digit = is_digit;
+ }
 g_free(text);
- return t;
+
+ text = eq_text->str;
+ g_string_free(eq_text, FALSE);
+
+ return text;
 }
 
 
@@ -803,17 +869,35 @@ math_equation_get_number(MathEquation *equation, MPNumber *z)
 gchar *text;
 gboolean result;
 
- text = math_equation_get_display(equation);
- result = !mp_set_from_string(text, equation->priv->base, z);
- g_free (text);
+ g_return_val_if_fail(equation != NULL, FALSE);
+ g_return_val_if_fail(z != NULL, FALSE);
 
- return result;
+ if (math_equation_is_result(equation)) {
+ mp_set_from_mp(math_equation_get_answer(equation), z);
+ return TRUE;
+ }
+ else {
+ text = math_equation_get_equation(equation);
+ result = !mp_serializer_from_string(equation->priv->serializer, text, z);
+ g_free(text);
+ return result;
+ }
+}
+
+
+MpSerializer *
+math_equation_get_serializer(MathEquation *equation)
+{
+ g_return_val_if_fail(equation != NULL, NULL);
+ return equation->priv->serializer;
 }
 
 
 void
 math_equation_set_number_mode(MathEquation *equation, NumberMode mode)
 {
+ g_return_if_fail(equation != NULL);
+
 if (equation->priv->number_mode == mode)
 return;
 
@@ -827,13 +911,23 @@ math_equation_set_number_mode(MathEquation *equation, NumberMode mode)
 NumberMode
 math_equation_get_number_mode(MathEquation *equation)
 {
+ g_return_val_if_fail(equation != NULL, NORMAL);
 return equation->priv->number_mode;
 }
 
 
+gboolean
+math_equation_in_solve(MathEquation *equation)
+{
+ g_return_val_if_fail(equation != NULL, FALSE);
+ return equation->priv->in_solve;
+}
+
+
 const MPNumber *
 math_equation_get_answer(MathEquation *equation)
 {
+ g_return_val_if_fail(equation != NULL, FALSE);
 return &equation->priv->state.ans;
 }
 
@@ -842,25 +936,31 @@ void
 math_equation_store(MathEquation *equation, const gchar *name)
 {
 MPNumber t;
+ 
+ g_return_if_fail(equation != NULL);
+ g_return_if_fail(name != NULL);
 
 if (!math_equation_get_number(equation, &t))
 math_equation_set_status(equation, _("No sane value to store"));
 else
- math_variables_set_value(equation->priv->variables, name, &t);
+ math_variables_set(equation->priv->variables, name, &t);
 }
 
 
 void
 math_equation_recall(MathEquation *equation, const gchar *name)
 {
+ g_return_if_fail(equation != NULL);
+ g_return_if_fail(name != NULL);
 math_equation_insert(equation, name);
 }
 
 
 void
 math_equation_set(MathEquation *equation, const gchar *text)
-
 {
+ g_return_if_fail(equation != NULL);
+ g_return_if_fail(text != NULL);
 gtk_text_buffer_set_text(GTK_TEXT_BUFFER(equation), text, -1);
 clear_ans(equation, FALSE);
 }
@@ -869,11 +969,14 @@ math_equation_set(MathEquation *equation, const gchar *text)
 void
 math_equation_set_number(MathEquation *equation, const MPNumber *x)
 {
- char text[MAX_DIGITS];
+ char *text;
 GtkTextIter start, end;
 
+ g_return_if_fail(equation != NULL);
+ g_return_if_fail(x != NULL);
+
 /* Show the number in the user chosen format */
- display_make_number(equation, text, MAX_DIGITS, x);
+ text = mp_serializer_to_string(equation->priv->serializer, x);
 gtk_text_buffer_set_text(GTK_TEXT_BUFFER(equation), text, -1);
 mp_set_from_mp(x, &equation->priv->state.ans);
 
@@ -883,12 +986,16 @@ math_equation_set_number(MathEquation *equation, const MPNumber *x)
 equation->priv->ans_start = gtk_text_buffer_create_mark(GTK_TEXT_BUFFER(equation), NULL, &start, FALSE);
 equation->priv->ans_end = gtk_text_buffer_create_mark(GTK_TEXT_BUFFER(equation), NULL, &end, TRUE);
 gtk_text_buffer_apply_tag(GTK_TEXT_BUFFER(equation), equation->priv->ans_tag, &start, &end);
+ g_free(text);
 }
 
 
 void
 math_equation_insert(MathEquation *equation, const gchar *text)
 {
+ g_return_if_fail(equation != NULL);
+ g_return_if_fail(text != NULL);
+
 /* Replace ** with ^ (not on all keyboards) */
 if (!gtk_text_buffer_get_has_selection(GTK_TEXT_BUFFER(equation)) &&
 strcmp(text, "×") == 0 && equation->priv->state.entered_multiply) {
@@ -900,10 +1007,6 @@ math_equation_insert(MathEquation *equation, const gchar *text)
 return;
 }
 
- /* Start new equation when entering digits after existing result */
- if(math_equation_is_result(equation) && g_unichar_isdigit(g_utf8_get_char(text)))
- gtk_text_buffer_set_text(GTK_TEXT_BUFFER(equation), "", -1);
-
 /* Can't enter superscript minus after entering digits */
 if (strstr("⁰¹²³⁴⁵⁶⁷⁸⁹", text) != NULL || strcmp("⁻", text) == 0)
 equation->priv->can_super_minus = FALSE;
@@ -912,8 +1015,6 @@ math_equation_insert(MathEquation *equation, const gchar *text)
 if (strstr("⁻⁰¹²³⁴⁵⁶⁷⁸⁹₀₁₂₃₄₅₆₇₈₉", text) == NULL)
 math_equation_set_number_mode(equation, NORMAL);
 
- // FIXME: Add thousands separators
-
 gtk_text_buffer_delete_selection(GTK_TEXT_BUFFER(equation), FALSE, FALSE);
 gtk_text_buffer_insert_at_cursor(GTK_TEXT_BUFFER(equation), text, -1);
 }
@@ -925,8 +1026,16 @@ math_equation_insert_digit(MathEquation *equation, guint digit)
 static const char *subscript_digits[] = {"₀", "₁", "₂", "₃", "₄", "₅", "₆", "₇", "₈", "₉", NULL};
 static const char *superscript_digits[] = {"⁰", "¹", "²", "³", "⁴", "⁵", "⁶", "⁷", "⁸", "⁹", NULL};
 
- if (equation->priv->number_mode == NORMAL || digit >= 10)
- math_equation_insert(equation, math_equation_get_digit_text(equation, digit));
+ g_return_if_fail(equation != NULL);
+ g_return_if_fail(digit < 16);
+
+ if (equation->priv->number_mode == NORMAL || digit >= 10) {
+ gchar buffer[7];
+ gint len;
+ len = g_unichar_to_utf8(math_equation_get_digit_text(equation, digit), buffer);
+ buffer[len] = '\0';
+ math_equation_insert(equation, buffer);
+ }
 else if (equation->priv->number_mode == SUPERSCRIPT)
 math_equation_insert(equation, superscript_digits[digit]);
 else if (equation->priv->number_mode == SUBSCRIPT)
@@ -937,22 +1046,35 @@ math_equation_insert_digit(MathEquation *equation, guint digit)
 void
 math_equation_insert_numeric_point(MathEquation *equation)
 {
- math_equation_insert(equation, math_equation_get_numeric_point_text(equation));
+ gchar buffer[7];
+ gint len;
+
+ g_return_if_fail(equation != NULL);
+
+ len = g_unichar_to_utf8(mp_serializer_get_radix(equation->priv->serializer), buffer);
+ buffer[len] = '\0';
+ math_equation_insert(equation, buffer);
 }
 
 
 void
 math_equation_insert_number(MathEquation *equation, const MPNumber *x)
 {
- char text[MAX_DIGITS];
- display_make_number(equation, text, MAX_DIGITS, x);
+ char *text;
+
+ g_return_if_fail(equation != NULL);
+ g_return_if_fail(x != NULL);
+
+ text = mp_serializer_to_string(equation->priv->serializer, x);
 math_equation_insert(equation, text);
+ g_free(text);
 }
 
 
 void
 math_equation_insert_exponent(MathEquation *equation)
 {
+ g_return_if_fail(equation != NULL);
 math_equation_insert(equation, "×10");
 math_equation_set_number_mode(equation, SUPERSCRIPT);
 }
@@ -961,6 +1083,7 @@ math_equation_insert_exponent(MathEquation *equation)
 void
 math_equation_insert_subtract(MathEquation *equation)
 {
+ g_return_if_fail(equation != NULL);
 if (equation->priv->number_mode == SUPERSCRIPT && equation->priv->can_super_minus) {
 math_equation_insert(equation, "⁻");
 equation->priv->can_super_minus = FALSE;
@@ -982,14 +1105,14 @@ variable_is_defined(const char *name, void *data)
 for (c = lower_name; *c; c++)
 *c = tolower(*c);
 
- if (strcmp(lower_name, "rand") == 0 ||
+ if (strcmp(lower_name, "rand") == 0 || 
 strcmp(lower_name, "ans") == 0) {
- g_free (lower_name);
+ g_free(lower_name);
 return 1;
 }
- g_free (lower_name);
+ g_free(lower_name);
 
- return math_variables_get_value(equation->priv->variables, name) != NULL;
+ return math_variables_get(equation->priv->variables, name) != NULL;
 }
 
 
@@ -1010,7 +1133,7 @@ get_variable(const char *name, MPNumber *z, void *data)
 else if (strcmp(lower_name, "ans") == 0)
 mp_set_from_mp(&equation->priv->state.ans, z);
 else {
- t = math_variables_get_value(equation->priv->variables, name);
+ t = math_variables_get(equation->priv->variables, name);
 if (t)
 mp_set_from_mp(t, z);
 else
@@ -1028,14 +1151,14 @@ set_variable(const char *name, const MPNumber *x, void *data)
 {
 MathEquation *equation = data;
 /* FIXME: Don't allow writing to built-in variables, e.g. ans, rand, sin, ... */
- math_variables_set_value(equation->priv->variables, name, x);
+ math_variables_set(equation->priv->variables, name, x);
 }
 
 
 static int
 convert(const MPNumber *x, const char *x_units, const char *z_units, MPNumber *z, void *data)
 {
- return currency_convert(x, x_units, z_units, z);
+ return unit_manager_convert_by_symbol(unit_manager_get_default(), x, x_units, z_units, z);
 }
 
 
@@ -1045,7 +1168,7 @@ parse(MathEquation *equation, const char *text, MPNumber *z, char **error_token)
 MPEquationOptions options;
 
 memset(&options, 0, sizeof(options));
- options.base = equation->priv->base;
+ options.base = mp_serializer_get_base(equation->priv->serializer);
 options.wordlen = equation->priv->word_size;
 options.angle_units = equation->priv->angle_units;
 options.variable_is_defined = variable_is_defined;
@@ -1058,25 +1181,20 @@ parse(MathEquation *equation, const char *text, MPNumber *z, char **error_token)
 }
 
 
-void
-math_equation_solve(MathEquation *equation)
+/*
+ * Executed in separate thread. It is thus not a good idea to write to anything
+ * in MathEquation but the async queue from here.
+ */
+static gpointer
+math_equation_solve_real(gpointer data)
 {
- MPNumber z;
- gint result, n_brackets = 0;
- gchar *c, *text, *error_token = NULL, *message = NULL;
- GString *equation_text;
-
- if (math_equation_is_empty(equation))
- return;
-
- /* If showing a result return to the equation that caused it */
- // FIXME: Result may not be here due to solve (i.e. the user may have entered "ans")
- if (math_equation_is_result(equation)) {
- math_equation_undo(equation);
- return;
- }
+ MathEquation *equation = MATH_EQUATION(data);
+ SolveData *solvedata = g_slice_new0(SolveData);
 
- math_equation_set_number_mode(equation, NORMAL);
+ gint n_brackets = 0, result;
+ gchar *c, *text, *error_token;
+ GString *equation_text;
+ MPNumber z;
 
 text = math_equation_get_equation(equation);
 equation_text = g_string_new(text);
@@ -1099,81 +1217,183 @@ math_equation_solve(MathEquation *equation)
 
 switch (result) {
 case PARSER_ERR_NONE:
- math_equation_set_number(equation, &z);
+ solvedata->number_result = g_slice_new(MPNumber);
+ mp_set_from_mp(&z, solvedata->number_result);
 break;
 
 case PARSER_ERR_OVERFLOW:
- message = g_strdup(/* Error displayed to user when they perform a bitwise operation on numbers greater than the current word */
+ solvedata->error = g_strdup(/* Error displayed to user when they perform a bitwise operation on numbers greater than the current word */
 _("Overflow. Try a bigger word size"));
 break;
 
 case PARSER_ERR_UNKNOWN_VARIABLE:
- message = g_strdup_printf(/* Error displayed to user when they an unknown variable is entered */
+ solvedata->error = g_strdup_printf(/* Error displayed to user when they an unknown variable is entered */
 _("Unknown variable '%s'"), error_token);
 break;
 
 case PARSER_ERR_UNKNOWN_FUNCTION:
- message = g_strdup_printf(/* Error displayed to user when an unknown function is entered */
+ solvedata->error = g_strdup_printf(/* Error displayed to user when an unknown function is entered */
 _("Function '%s' is not defined"), error_token);
 break;
 
 case PARSER_ERR_UNKNOWN_CONVERSION:
- message = g_strdup(/* Error displayed to user when an conversion with unknown units is attempted */
+ solvedata->error = g_strdup(/* Error displayed to user when an conversion with unknown units is attempted */
 _("Unknown conversion"));
 break;
 
 case PARSER_ERR_MP:
- message = g_strdup(mp_get_error());
+ if (mp_get_error())
+ solvedata->error = g_strdup(mp_get_error());
+ else if (error_token)
+ solvedata->error = g_strdup_printf(/* Uncategorized error. Show error token to user*/
+ _("Malformed expression at token '%s'"), error_token);
+ else
+ solvedata->error = g_strdup (/* Unknown error. */
+ _("Malformed expression"));
 break;
 
 default:
- message = g_strdup(/* Error displayed to user when they enter an invalid calculation */
+ solvedata->error = g_strdup(/* Error displayed to user when they enter an invalid calculation */
 _("Malformed expression"));
 break;
 }
+ g_async_queue_push(equation->priv->queue, solvedata);
+
+ return NULL;
+}
+
 
- if (error_token)
- free(error_token);
+static gboolean
+math_equation_show_in_progress(gpointer data)
+{
+ MathEquation *equation = MATH_EQUATION(data);
+ if (equation->priv->in_solve)
+ math_equation_set_status(equation, _("Calculating"));
+ return false;
+}
 
- if (message) {
- math_equation_set_status(equation, message);
- g_free(message);
+
+static gboolean
+math_equation_look_for_answer(gpointer data)
+{
+ MathEquation *equation = MATH_EQUATION(data);
+ SolveData *result = g_async_queue_try_pop(equation->priv->queue);
+
+ if (result == NULL)
+ return true;
+
+ equation->priv->in_solve = false;
+
+ if (!result->error)
+ math_equation_set_status(equation, "");
+
+ if (result->error != NULL) {
+ math_equation_set_status(equation, result->error);
+ g_free(result->error);
+ }
+ else if (result->number_result != NULL) {
+ math_equation_set_number(equation, result->number_result);
+ g_slice_free(MPNumber, result->number_result);
 }
+ else if (result->text_result != NULL) {
+ math_equation_set(equation, result->text_result);
+ g_free(result->text_result);
+ }
+ g_slice_free(SolveData, result);
+
+ return false;
 }
 
 
 void
-math_equation_factorize(MathEquation *equation)
+math_equation_solve(MathEquation *equation)
 {
- MPNumber x;
- GList *factors, *factor;
- GString *text;
+ g_return_if_fail(equation != NULL);
 
- if (!math_equation_get_number(equation, &x) || !mp_is_integer(&x)) {
- /* Error displayed when trying to factorize a non-integer value */
- math_equation_set_status(equation, _("Need an integer to factorize"));
+ // FIXME: should replace calculation or give error message
+ if (equation->priv->in_solve)
+ return;
+
+ if (math_equation_is_empty(equation))
+ return;
+
+ /* If showing a result return to the equation that caused it */
+ // FIXME: Result may not be here due to solve (i.e. the user may have entered "ans")
+ if (math_equation_is_result(equation)) {
+ math_equation_undo(equation);
 return;
 }
 
+ equation->priv->in_solve = true;
+
+ math_equation_set_number_mode(equation, NORMAL);
+
+ g_thread_new("", math_equation_solve_real, equation);
+
+ g_timeout_add(50, math_equation_look_for_answer, equation);
+ g_timeout_add(100, math_equation_show_in_progress, equation);
+}
+
+
+static gpointer
+math_equation_factorize_real(gpointer data)
+{
+ GString *text;
+ GList *factors, *factor;
+ MPNumber x;
+ MathEquation *equation = MATH_EQUATION(data);
+ SolveData *result = g_slice_new0(SolveData);
+
+ math_equation_get_number(equation, &x);
 factors = mp_factorize(&x);
 
 text = g_string_new("");
 
 for (factor = factors; factor; factor = factor->next) {
- gchar temp[MAX_DIGITS];
+ gchar *temp;
 MPNumber *n;
 
 n = factor->data;
- display_make_number(equation, temp, MAX_DIGITS, n);
+ temp = mp_serializer_to_string(equation->priv->serializer, n);
 g_string_append(text, temp);
 if (factor->next)
 g_string_append(text, "×");
 g_slice_free(MPNumber, n);
+ g_free(temp);
 }
 g_list_free(factors);
 
- math_equation_set(equation, text->str);
+ result->text_result = g_strndup(text->str, text->len);
+ g_async_queue_push(equation->priv->queue, result);
 g_string_free(text, TRUE);
+
+ return NULL;
+}
+
+
+void
+math_equation_factorize(MathEquation *equation)
+{
+ MPNumber x;
+
+ g_return_if_fail(equation != NULL);
+
+ // FIXME: should replace calculation or give error message
+ if (equation->priv->in_solve)
+ return;
+
+ if (!math_equation_get_number(equation, &x) || !mp_is_integer(&x)) {
+ /* Error displayed when trying to factorize a non-integer value */
+ math_equation_set_status(equation, _("Need an integer to factorize"));
+ return;
+ }
+
+ equation->priv->in_solve = true;
+
+ g_thread_new("", math_equation_factorize_real, equation);
+
+ g_timeout_add(50, math_equation_look_for_answer, equation);
+ g_timeout_add(100, math_equation_show_in_progress, equation);
 }
 
 
@@ -1183,6 +1403,8 @@ math_equation_delete(MathEquation *equation)
 gint cursor;
 GtkTextIter start, end;
 
+ g_return_if_fail(equation != NULL);
+
 g_object_get(G_OBJECT(equation), "cursor-position", &cursor, NULL);
 if (cursor >= gtk_text_buffer_get_char_count(GTK_TEXT_BUFFER(equation)))
 return;
@@ -1196,6 +1418,8 @@ math_equation_delete(MathEquation *equation)
 void
 math_equation_backspace(MathEquation *equation)
 {
+ g_return_if_fail(equation != NULL);
+
 /* Can't delete empty display */
 if (math_equation_is_empty(equation))
 return;
@@ -1213,6 +1437,8 @@ math_equation_backspace(MathEquation *equation)
 void
 math_equation_clear(MathEquation *equation)
 {
+ g_return_if_fail(equation != NULL);
+
 math_equation_set_number_mode(equation, NORMAL);
 gtk_text_buffer_set_text(GTK_TEXT_BUFFER(equation), "", -1);
 clear_ans(equation, FALSE);
@@ -1224,6 +1450,8 @@ math_equation_shift(MathEquation *equation, gint count)
 {
 MPNumber z;
 
+ g_return_if_fail(equation != NULL);
+
 if (!math_equation_get_number(equation, &z)) {
 math_equation_set_status(equation,
 /* This message is displayed in the status bar when a bit
@@ -1244,6 +1472,8 @@ math_equation_toggle_bit(MathEquation *equation, guint bit)
 guint64 bits;
 gboolean result;
 
+ g_return_if_fail(equation != NULL);
+
 result = math_equation_get_number(equation, &x);
 if (result) {
 MPNumber max;
@@ -1270,25 +1500,6 @@ math_equation_toggle_bit(MathEquation *equation, guint bit)
 }
 
 
-/* Convert MP number to character string. */
-//FIXME: What to do with this?
-void
-display_make_number(MathEquation *equation, char *target, int target_len, const MPNumber *x)
-{
- switch(equation->priv->format) {
- case FIX:
- mp_cast_to_string(x, equation->priv->base, equation->priv->base, equation->priv->accuracy, !equation->priv->show_zeroes, target, target_len);
- break;
- case SCI:
- mp_cast_to_exponential_string(x, equation->priv->base, equation->priv->base, equation->priv->accuracy, !equation->priv->show_zeroes, false, target, target_len);
- break;
- case ENG:
- mp_cast_to_exponential_string(x, equation->priv->base, equation->priv->base, equation->priv->accuracy, !equation->priv->show_zeroes, true, target, target_len);
- break;
- }
-}
-
-
 static void
 math_equation_set_property(GObject *object,
 guint prop_id,
@@ -1297,7 +1508,7 @@ math_equation_set_property(GObject *object,
 {
 MathEquation *self;
 
- self = MATH_EQUATION (object);
+ self = MATH_EQUATION(object);
 
 switch (prop_id) {
 case PROP_STATUS:
@@ -1336,8 +1547,14 @@ math_equation_set_property(GObject *object,
 case PROP_TARGET_CURRENCY:
 math_equation_set_target_currency(self, g_value_get_string(value));
 break;
+ case PROP_SOURCE_UNITS:
+ math_equation_set_source_units(self, g_value_get_string(value));
+ break;
+ case PROP_TARGET_UNITS:
+ math_equation_set_target_units(self, g_value_get_string(value));
+ break;
 default:
- G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 break;
 }
 }
@@ -1352,14 +1569,14 @@ math_equation_get_property(GObject *object,
 MathEquation *self;
 gchar *text;
 
- self = MATH_EQUATION (object);
+ self = MATH_EQUATION(object);
 
 switch (prop_id) {
 case PROP_STATUS:
 g_value_set_string(value, self->priv->state.status);
 break;
 case PROP_DISPLAY:
- text = math_equation_get_display(self);
+ text = math_equation_get_display(self); 
 g_value_set_string(value, text);
 g_free(text);
 break;
@@ -1372,16 +1589,16 @@ math_equation_get_property(GObject *object,
 g_value_set_enum(value, self->priv->number_mode);
 break;
 case PROP_ACCURACY:
- g_value_set_int(value, self->priv->accuracy);
+ g_value_set_int(value, mp_serializer_get_trailing_digits(self->priv->serializer));
 break;
 case PROP_SHOW_THOUSANDS_SEPARATORS:
- g_value_set_boolean(value, self->priv->show_tsep);
+ g_value_set_boolean(value, mp_serializer_get_show_thousands_separators(self->priv->serializer));
 break;
 case PROP_SHOW_TRAILING_ZEROES:
- g_value_set_boolean(value, self->priv->show_zeroes);
+ g_value_set_boolean(value, mp_serializer_get_show_trailing_zeroes(self->priv->serializer));
 break;
 case PROP_NUMBER_FORMAT:
- g_value_set_enum(value, self->priv->format);
+ g_value_set_enum(value, mp_serializer_get_number_format(self->priv->serializer));
 break;
 case PROP_BASE:
 g_value_set_int(value, math_equation_get_base(self));
@@ -1398,15 +1615,36 @@ math_equation_get_property(GObject *object,
 case PROP_TARGET_CURRENCY:
 g_value_set_string(value, self->priv->target_currency);
 break;
+ case PROP_SOURCE_UNITS:
+ g_value_set_string(value, self->priv->source_units);
+ break;
+ case PROP_TARGET_UNITS:
+ g_value_set_string(value, self->priv->target_units);
+ break;
+ case PROP_SERIALIZER:
+ g_value_set_object(value, self->priv->serializer);
+ break;
 default:
- G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 break;
 }
 }
 
 
 static void
-math_equation_class_init (MathEquationClass *klass)
+math_equation_constructed(GObject *object)
+{
+ GtkTextBuffer *parent_class;
+ parent_class = g_type_class_peek_parent(MATH_EQUATION_GET_CLASS(object));
+ if (G_OBJECT_CLASS(parent_class)->constructed)
+ G_OBJECT_CLASS(parent_class)->constructed(object);
+
+ MATH_EQUATION(object)->priv->ans_tag = gtk_text_buffer_create_tag(GTK_TEXT_BUFFER(object), NULL, "weight", PANGO_WEIGHT_BOLD, NULL);
+}
+
+
+static void
+math_equation_class_init(MathEquationClass *klass)
 {
 static GEnumValue number_mode_values[] =
 {
@@ -1415,13 +1653,6 @@ math_equation_class_init (MathEquationClass *klass)
 {SUBSCRIPT, "subscript", "subscript"},
 {0, NULL, NULL}
 };
- static GEnumValue number_format_values[] =
- {
- {FIX, "fixed-point", "fixed-point"},
- {SCI, "scientific", "scientific"},
- {ENG, "engineering", "engineering"},
- {0, NULL, NULL}
- };
 static GEnumValue angle_unit_values[] =
 {
 {MP_RADIANS, "radians", "radians"},
@@ -1429,15 +1660,16 @@ math_equation_class_init (MathEquationClass *klass)
 {MP_GRADIANS, "gradians", "gradians"},
 {0, NULL, NULL}
 };
- GObjectClass *object_class = G_OBJECT_CLASS (klass);
+ GObjectClass *object_class = G_OBJECT_CLASS(klass);
 
 object_class->get_property = math_equation_get_property;
 object_class->set_property = math_equation_set_property;
+ object_class->constructed = math_equation_constructed;
 
- g_type_class_add_private (klass, sizeof (MathEquationPrivate));
-
+ g_type_class_add_private(klass, sizeof(MathEquationPrivate));
+ 
 number_mode_type = g_enum_register_static("NumberMode", number_mode_values);
- number_format_type = g_enum_register_static("DisplayFormat", number_format_values);
+ number_format_type = math_mp_display_format_get_type();
 angle_unit_type = g_enum_register_static("AngleUnit", angle_unit_values);
 
 g_object_class_install_property(object_class,
@@ -1496,14 +1728,14 @@ math_equation_class_init (MathEquationClass *klass)
 "number-format",
 "Display format",
 number_format_type,
- FIX,
+ MP_DISPLAY_FORMAT_FIXED,
 G_PARAM_READWRITE));
 g_object_class_install_property(object_class,
 PROP_BASE,
 g_param_spec_int("base",
 "base",
 "Default number base (derived from number-format)",
- 2, 16, 10,
+ 2, 16, 10, 
 G_PARAM_READWRITE));
 g_object_class_install_property(object_class,
 PROP_WORD_SIZE,
@@ -1534,30 +1766,54 @@ math_equation_class_init (MathEquationClass *klass)
 "target Currency",
 "",
 G_PARAM_READWRITE));
+ g_object_class_install_property(object_class,
+ PROP_SOURCE_UNITS,
+ g_param_spec_string("source-units",
+ "source-units",
+ "Source Units",
+ "",
+ G_PARAM_READWRITE));
+ g_object_class_install_property(object_class,
+ PROP_TARGET_UNITS,
+ g_param_spec_string("target-units",
+ "target-units",
+ "target Units",
+ "",
+ G_PARAM_READWRITE));
+ g_object_class_install_property(object_class,
+ PROP_SERIALIZER,
+ g_param_spec_object("serializer",
+ "serializer",
+ "Serializer",
+ MP_TYPE_SERIALIZER,
+ G_PARAM_READABLE));
 }
 
 
 static void
-pre_insert_text_cb (MathEquation *equation,
- GtkTextIter *location,
- gchar *text,
- gint len,
- gpointer user_data)
+pre_insert_text_cb(MathEquation *equation,
+ GtkTextIter *location,
+ gchar *text,
+ gint len,
+ gpointer user_data)
 {
 gunichar c;
-
+ gint cursor;
+ 
 if (equation->priv->in_reformat)
 return;
-
+ 
 /* If following a delete then have already pushed undo stack (GtkTextBuffer
 doesn't indicate replace operations so we have to infer them) */
 if (!equation->priv->in_delete)
 math_equation_push_undo_stack(equation);
 
 /* Clear result on next digit entered if cursor at end of line */
- // FIXME Cursor
 c = g_utf8_get_char(text);
- if (g_unichar_isdigit(c) && math_equation_is_result(equation)) {
+ g_object_get(G_OBJECT(equation), "cursor-position", &cursor, NULL);
+ if ((g_unichar_isdigit(c) || c == mp_serializer_get_radix(equation->priv->serializer)) &&
+ math_equation_is_result(equation) &&
+ cursor >= gtk_text_buffer_get_char_count(GTK_TEXT_BUFFER(equation))) {
 gtk_text_buffer_set_text(GTK_TEXT_BUFFER(equation), "", -1);
 clear_ans(equation, FALSE);
 gtk_text_buffer_get_end_iter(GTK_TEXT_BUFFER(equation), location);
@@ -1569,7 +1825,7 @@ pre_insert_text_cb (MathEquation *equation,
 
 offset = gtk_text_iter_get_offset(location);
 get_ans_offsets(equation, &ans_start, &ans_end);
-
+ 
 /* Inserted inside ans */
 if (offset > ans_start && offset < ans_end)
 clear_ans(equation, TRUE);
@@ -1580,17 +1836,17 @@ pre_insert_text_cb (MathEquation *equation,
 static gboolean
 on_delete(MathEquation *equation)
 {
- equation->priv->in_delete = FALSE;
- return FALSE;
+ equation->priv->in_delete = FALSE; 
+ return FALSE;
 }
 
 
 static void
-pre_delete_range_cb (MathEquation *equation,
- GtkTextIter *start,
- GtkTextIter *end,
- gpointer user_data)
-{
+pre_delete_range_cb(MathEquation *equation,
+ GtkTextIter *start,
+ GtkTextIter *end,
+ gpointer user_data)
+{ 
 if (equation->priv->in_reformat)
 return;
 
@@ -1606,7 +1862,7 @@ pre_delete_range_cb (MathEquation *equation,
 start_offset = gtk_text_iter_get_offset(start);
 end_offset = gtk_text_iter_get_offset(end);
 get_ans_offsets(equation, &ans_start, &ans_end);
-
+ 
 /* Deleted part of ans */
 if (start_offset < ans_end && end_offset > ans_start)
 clear_ans(equation, TRUE);
@@ -1615,29 +1871,38 @@ pre_delete_range_cb (MathEquation *equation,
 
 
 static void
-insert_text_cb (MathEquation *equation,
- GtkTextIter *location,
- gchar *text,
- gint len,
- gpointer user_data)
+insert_text_cb(MathEquation *equation,
+ GtkTextIter *location,
+ gchar *text,
+ gint len,
+ gpointer user_data)
 {
 if (equation->priv->in_reformat)
 return;
 
 equation->priv->state.entered_multiply = strcmp(text, "×") == 0;
+
+ /* Update thousands separators */
+ reformat_separators(equation);
+
 g_object_notify(G_OBJECT(equation), "display");
 }
 
 
 static void
-delete_range_cb (MathEquation *equation,
- GtkTextIter *start,
- GtkTextIter *end,
- gpointer user_data)
+delete_range_cb(MathEquation *equation,
+ GtkTextIter *start,
+ GtkTextIter *end,
+ gpointer user_data)
 {
 if (equation->priv->in_reformat)
 return;
 
+ equation->priv->state.entered_multiply = FALSE;
+
+ /* Update thousands separators */
+ reformat_separators(equation);
+
 // FIXME: A replace will emit this both for delete-range and insert-text, can it be avoided?
 g_object_notify(G_OBJECT(equation), "display");
 }
@@ -1649,19 +1914,16 @@ math_equation_init(MathEquation *equation)
 /* Digits localized for the given language */
 const char *digit_values = _("0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F");
 const char *default_digits[] = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"};
- gchar *radix, *tsep;
 gchar **digits;
- gboolean use_default_digits = FALSE;
+ /* Default to using untranslated digits, this is because it doesn't make sense in most languages and we need to make this optional.
+ * See https://bugzilla.gnome.org/show_bug.cgi?id=632661 */
+ gboolean use_default_digits = TRUE;
 int i;
 
- equation->priv = G_TYPE_INSTANCE_GET_PRIVATE (equation, math_equation_get_type(), MathEquationPrivate);
-
- // FIXME: Causes error
- // (process:18573): Gtk-CRITICAL **: set_table: assertion buffer->tag_table == NULL' failed
- equation->priv->ans_tag = gtk_text_buffer_create_tag(GTK_TEXT_BUFFER(equation), NULL, "weight", PANGO_WEIGHT_BOLD, NULL);
+ equation->priv = G_TYPE_INSTANCE_GET_PRIVATE(equation, math_equation_get_type(), MathEquationPrivate);
 
 g_signal_connect(equation, "insert-text", G_CALLBACK(pre_insert_text_cb), equation);
- g_signal_connect(equation, "delete-range", G_CALLBACK(pre_delete_range_cb), equation);
+ g_signal_connect(equation, "delete-range", G_CALLBACK(pre_delete_range_cb), equation); 
 g_signal_connect_after(equation, "insert-text", G_CALLBACK(insert_text_cb), equation);
 g_signal_connect_after(equation, "delete-range", G_CALLBACK(delete_range_cb), equation);
 
@@ -1669,35 +1931,25 @@ math_equation_init(MathEquation *equation)
 for (i = 0; i < 16; i++) {
 if (use_default_digits || digits[i] == NULL) {
 use_default_digits = TRUE;
- equation->priv->digits[i] = strdup(default_digits[i]);
+ equation->priv->digits[i] = g_utf8_get_char(default_digits[i]);
 }
 else
- equation->priv->digits[i] = strdup(digits[i]);
+ equation->priv->digits[i] = g_utf8_get_char(digits[i]);
 }
 g_strfreev(digits);
 
- setlocale(LC_NUMERIC, "");
-
- radix = nl_langinfo(RADIXCHAR);
- equation->priv->radix = radix ? g_locale_to_utf8(radix, -1, NULL, NULL, NULL) : g_strdup(".");
- tsep = nl_langinfo(THOUSEP);
- equation->priv->tsep = tsep ? g_locale_to_utf8(tsep, -1, NULL, NULL, NULL) : g_strdup(",");
-
- equation->priv->tsep_count = 3;
-
 equation->priv->variables = math_variables_new();
 
 equation->priv->state.status = g_strdup("");
- equation->priv->show_zeroes = FALSE;
- equation->priv->show_tsep = FALSE;
- equation->priv->format = FIX;
- equation->priv->accuracy = 9;
 equation->priv->word_size = 32;
 equation->priv->angle_units = MP_DEGREES;
 // FIXME: Pick based on locale
- equation->priv->source_currency = g_strdup(currency_names[0].short_name);
- equation->priv->target_currency = g_strdup(currency_names[0].short_name);
- equation->priv->base = 10;
+ equation->priv->source_currency = g_strdup("");
+ equation->priv->target_currency = g_strdup("");
+ equation->priv->source_units = g_strdup("");
+ equation->priv->target_units = g_strdup("");
+ equation->priv->serializer = mp_serializer_new(MP_DISPLAY_FORMAT_AUTOMATIC, 10, 9);
+ equation->priv->queue = g_async_queue_new();
 
 mp_set_from_integer(0, &equation->priv->state.ans);
 }