Update codebase.

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);
 }