summaryrefslogtreecommitdiff
path: root/src/math-equation.c
diff options
context:
space:
mode:
authorPerberos <[email protected]>2011-11-08 13:50:37 -0300
committerPerberos <[email protected]>2011-11-08 13:50:37 -0300
commit2358ba4314dc6d757049bc4871ecf2922614b61b (patch)
tree12e52f491560916f0458c87b2d98ffa94500cb0f /src/math-equation.c
downloadmate-calc-2358ba4314dc6d757049bc4871ecf2922614b61b.tar.bz2
mate-calc-2358ba4314dc6d757049bc4871ecf2922614b61b.tar.xz
initial
Diffstat (limited to 'src/math-equation.c')
-rw-r--r--src/math-equation.c1701
1 files changed, 1701 insertions, 0 deletions
diff --git a/src/math-equation.c b/src/math-equation.c
new file mode 100644
index 0000000..af68cd1
--- /dev/null
+++ b/src/math-equation.c
@@ -0,0 +1,1701 @@
+/* Copyright (c) 1987-2008 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright (c) 2008-2009 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., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <math.h>
+#include <errno.h>
+#include <glib.h>
+#include <langinfo.h>
+#include <locale.h>
+
+#include "math-equation.h"
+
+#include "mp.h"
+#include "mp-equation.h"
+#include "currency.h"
+
+
+enum {
+ PROP_0,
+ PROP_STATUS,
+ PROP_DISPLAY,
+ PROP_EQUATION,
+ PROP_NUMBER_MODE,
+ PROP_ACCURACY,
+ PROP_SHOW_THOUSANDS_SEPARATORS,
+ PROP_SHOW_TRAILING_ZEROES,
+ PROP_NUMBER_FORMAT,
+ PROP_BASE,
+ PROP_WORD_SIZE,
+ PROP_ANGLE_UNITS,
+ PROP_SOURCE_CURRENCY,
+ PROP_TARGET_CURRENCY
+};
+
+static GType number_mode_type, number_format_type, angle_unit_type;
+
+#define MAX_DIGITS 512
+
+/* Expression mode state */
+typedef struct {
+ MPNumber ans; /* Previously calculated answer */
+ gchar *expression; /* Expression entered by user */
+ gint ans_start, ans_end; /* Start and end characters for ans variable in expression */
+ gint cursor; /* ??? */
+ NumberMode number_mode; /* ??? */
+ gboolean can_super_minus; /* TRUE if entering minus can generate a superscript minus */
+ gboolean entered_multiply; /* Last insert was a multiply character */
+ gchar *status; /* Equation status */
+} MathEquationState;
+
+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 */
+ 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. */
+
+ GtkTextMark *ans_start, *ans_end;
+
+ MathEquationState state; /* Equation state */
+ GList *undo_stack; /* History of expression mode states */
+ GList *redo_stack;
+ gboolean in_undo_operation;
+
+ gboolean in_reformat;
+
+ gboolean in_delete;
+
+ MathVariables *variables;
+};
+
+G_DEFINE_TYPE (MathEquation, math_equation, GTK_TYPE_TEXT_BUFFER);
+
+
+MathEquation *
+math_equation_new()
+{
+ return g_object_new (math_equation_get_type(), NULL);
+}
+
+
+MathVariables *
+math_equation_get_variables(MathEquation *equation)
+{
+ return equation->priv->variables;
+}
+
+
+static void
+get_ans_offsets(MathEquation *equation, gint *start, gint *end)
+{
+ GtkTextIter iter;
+
+ if (!equation->priv->ans_start) {
+ *start = *end = -1;
+ return;
+ }
+
+ gtk_text_buffer_get_iter_at_mark(GTK_TEXT_BUFFER(equation), &iter, equation->priv->ans_start);
+ *start = gtk_text_iter_get_offset(&iter);
+ gtk_text_buffer_get_iter_at_mark(GTK_TEXT_BUFFER(equation), &iter, equation->priv->ans_end);
+ *end = gtk_text_iter_get_offset(&iter);
+}
+
+
+static void
+reformat_ans(MathEquation *equation)
+{
+ if (!equation->priv->ans_start)
+ return;
+
+ gchar *orig_ans_text;
+ gchar ans_text[MAX_DIGITS];
+ 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);
+ if (strcmp(orig_ans_text, ans_text) != 0) {
+ gint start;
+
+ equation->priv->in_undo_operation = TRUE;
+ equation->priv->in_reformat = TRUE;
+
+ start = gtk_text_iter_get_offset(&ans_start);
+ gtk_text_buffer_delete(GTK_TEXT_BUFFER(equation), &ans_start, &ans_end);
+ gtk_text_buffer_insert_with_tags(GTK_TEXT_BUFFER(equation), &ans_end, ans_text, -1, equation->priv->ans_tag, NULL);
+
+ /* There seems to be a bug in the marks as they alternate being the correct and incorrect ways. Reset them */
+ gtk_text_buffer_get_iter_at_offset(GTK_TEXT_BUFFER(equation), &ans_start, start);
+ gtk_text_buffer_move_mark(GTK_TEXT_BUFFER(equation), equation->priv->ans_start, &ans_start);
+ gtk_text_buffer_move_mark(GTK_TEXT_BUFFER(equation), equation->priv->ans_end, &ans_end);
+
+ equation->priv->in_reformat = FALSE;
+ equation->priv->in_undo_operation = FALSE;
+ }
+ 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);
+}
+
+
+/* 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)
+{
+ 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;
+
+ if (equation->priv->base == old_base)
+ return;
+
+ sub_zero = g_utf8_get_char("₀");
+ sub_nine = g_utf8_get_char("₉");
+
+ read_iter = text = math_equation_get_display(equation);
+ get_ans_offsets(equation, &ans_start, &ans_end);
+ while (TRUE) {
+ gunichar c;
+ gint digit = -1, sub_digit = -1;
+
+ /* 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);
+
+ /* Don't mess with ans */
+ if (offset >= ans_start && offset <= ans_end) {
+ digit = -1;
+ sub_digit = -1;
+ }
+
+ 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;
+ }
+
+ base = base * 10 + sub_digit;
+ }
+ 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) {
+ 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_delete(GTK_TEXT_BUFFER(equation), &start, &end);
+ offset_step -= offset - base_offset;
+
+ equation->priv->in_reformat = FALSE;
+ equation->priv->in_undo_operation = FALSE;
+ }
+
+ in_number = FALSE;
+ }
+ else if (digit >= 0) {
+ in_number = TRUE;
+ have_radix = FALSE;
+ base = -1;
+ max_digit = digit;
+ }
+
+ 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
+}
+
+
+static void
+reformat_display(MathEquation *equation, gint old_base)
+{
+ /* 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);
+}
+
+
+static MathEquationState *
+get_current_state(MathEquation *equation)
+{
+ MathEquationState *state;
+ gint ans_start = -1, ans_end = -1;
+
+ state = g_malloc0(sizeof(MathEquationState));
+
+ if (equation->priv->ans_start)
+ {
+ GtkTextIter iter;
+ gtk_text_buffer_get_iter_at_mark(GTK_TEXT_BUFFER(equation), &iter, equation->priv->ans_start);
+ ans_start = gtk_text_iter_get_offset(&iter);
+ gtk_text_buffer_get_iter_at_mark(GTK_TEXT_BUFFER(equation), &iter, equation->priv->ans_end);
+ ans_end = gtk_text_iter_get_offset(&iter);
+ }
+
+ mp_set_from_mp(&equation->priv->state.ans, &state->ans);
+ state->expression = math_equation_get_display(equation);
+ state->ans_start = ans_start;
+ state->ans_end = ans_end;
+ g_object_get(G_OBJECT(equation), "cursor-position", &state->cursor, NULL);
+ state->number_mode = equation->priv->number_mode;
+ 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;
+}
+
+
+static void
+free_state(MathEquationState *state)
+{
+ g_free(state->expression);
+ g_free(state->status);
+ g_free(state);
+}
+
+
+static void
+math_equation_push_undo_stack(MathEquation *equation)
+{
+ GList *link;
+ MathEquationState *state;
+
+ if (equation->priv->in_undo_operation)
+ return;
+
+ math_equation_set_status(equation, "");
+
+ /* Can't redo anymore */
+ for (link = equation->priv->redo_stack; link; link = link->next) {
+ state = link->data;
+ free_state(state);
+ }
+ g_list_free(equation->priv->redo_stack);
+ equation->priv->redo_stack = NULL;
+
+ state = get_current_state(equation);
+ equation->priv->undo_stack = g_list_prepend(equation->priv->undo_stack, state);
+}
+
+
+static void
+clear_ans(MathEquation *equation, gboolean remove_tag)
+{
+ if (!equation->priv->ans_start)
+ return;
+
+ if (remove_tag) {
+ GtkTextIter start, end;
+
+ gtk_text_buffer_get_iter_at_mark(GTK_TEXT_BUFFER(equation), &start, equation->priv->ans_start);
+ gtk_text_buffer_get_iter_at_mark(GTK_TEXT_BUFFER(equation), &end, equation->priv->ans_end);
+ gtk_text_buffer_remove_tag(GTK_TEXT_BUFFER(equation), equation->priv->ans_tag, &start, &end);
+ }
+
+ gtk_text_buffer_delete_mark(GTK_TEXT_BUFFER(equation), equation->priv->ans_start);
+ gtk_text_buffer_delete_mark(GTK_TEXT_BUFFER(equation), equation->priv->ans_end);
+ equation->priv->ans_start = NULL;
+ equation->priv->ans_end = NULL;
+}
+
+
+static void
+apply_state(MathEquation *equation, MathEquationState *state)
+{
+ GtkTextIter cursor;
+
+ /* Disable undo detection */
+ equation->priv->in_undo_operation = TRUE;
+
+ mp_set_from_mp(&state->ans, &equation->priv->state.ans);
+
+ gtk_text_buffer_set_text(GTK_TEXT_BUFFER(equation), state->expression, -1);
+ gtk_text_buffer_get_iter_at_offset(GTK_TEXT_BUFFER(equation), &cursor, state->cursor);
+ gtk_text_buffer_place_cursor(GTK_TEXT_BUFFER(equation), &cursor);
+ clear_ans(equation, FALSE);
+ if (state->ans_start >= 0) {
+ GtkTextIter start, end;
+
+ gtk_text_buffer_get_iter_at_offset(GTK_TEXT_BUFFER(equation), &start, state->ans_start);
+ equation->priv->ans_start = gtk_text_buffer_create_mark(GTK_TEXT_BUFFER(equation), NULL, &start, FALSE);
+ gtk_text_buffer_get_iter_at_offset(GTK_TEXT_BUFFER(equation), &end, state->ans_end);
+ 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);
+ }
+
+ math_equation_set_number_mode(equation, state->number_mode);
+ equation->priv->can_super_minus = state->can_super_minus;
+ equation->priv->state.entered_multiply = state->entered_multiply;
+ math_equation_set_status(equation, state->status);
+
+ equation->priv->in_undo_operation = FALSE;
+}
+
+
+void
+math_equation_copy(MathEquation *equation)
+{
+ GtkTextIter start, end;
+ gchar *text;
+
+ 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);
+}
+
+
+static void
+on_paste(GtkClipboard *clipboard, const gchar *text, gpointer data)
+{
+ MathEquation *equation = data;
+ math_equation_insert (equation, text);
+}
+
+
+void
+math_equation_paste(MathEquation *equation)
+{
+ gtk_clipboard_request_text(gtk_clipboard_get(GDK_NONE), on_paste, equation);
+}
+
+
+void
+math_equation_undo(MathEquation *equation)
+{
+ GList *link;
+ MathEquationState *state;
+
+ if (!equation->priv->undo_stack) {
+ math_equation_set_status(equation,
+ /* Error shown when trying to undo with no undo history */
+ _("No undo history"));
+ return;
+ }
+
+ link = equation->priv->undo_stack;
+ equation->priv->undo_stack = g_list_remove_link(equation->priv->undo_stack, link);
+ state = link->data;
+ g_list_free(link);
+
+ equation->priv->redo_stack = g_list_prepend(equation->priv->redo_stack, get_current_state(equation));
+
+ apply_state(equation, state);
+ free_state(state);
+}
+
+
+void
+math_equation_redo(MathEquation *equation)
+{
+ GList *link;
+ MathEquationState *state;
+
+ if (!equation->priv->redo_stack) {
+ math_equation_set_status(equation,
+ /* Error shown when trying to redo with no redo history */
+ _("No redo history"));
+ return;
+ }
+
+ link = equation->priv->redo_stack;
+ equation->priv->redo_stack = g_list_remove_link(equation->priv->redo_stack, link);
+ state = link->data;
+ g_list_free(link);
+
+ equation->priv->undo_stack = g_list_prepend(equation->priv->undo_stack, get_current_state(equation));
+
+ apply_state(equation, state);
+ free_state(state);
+}
+
+
+const gchar *
+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;
+}
+
+
+const gchar *math_equation_get_thousands_separator_text(MathEquation *equation)
+{
+ return equation->priv->tsep;
+}
+
+
+void
+math_equation_set_accuracy(MathEquation *equation, gint accuracy)
+{
+ if (equation->priv->accuracy == accuracy)
+ return;
+ equation->priv->accuracy = accuracy;
+ reformat_display(equation, equation->priv->base);
+ g_object_notify(G_OBJECT(equation), "accuracy");
+}
+
+
+gint
+math_equation_get_accuracy(MathEquation *equation)
+{
+ return equation->priv->accuracy;
+}
+
+
+void
+math_equation_set_show_thousands_separators(MathEquation *equation, gboolean visible)
+{
+ if ((equation->priv->show_tsep && visible) || (!equation->priv->show_tsep && !visible))
+ return;
+ equation->priv->show_tsep = visible;
+ reformat_display(equation, equation->priv->base);
+ g_object_notify(G_OBJECT(equation), "show-thousands-separators");
+}
+
+
+gboolean
+math_equation_get_show_thousands_separators(MathEquation *equation)
+{
+ return equation->priv->show_tsep;
+}
+
+
+void
+math_equation_set_show_trailing_zeroes(MathEquation *equation, gboolean visible)
+{
+ if ((equation->priv->show_zeroes && visible) || (!equation->priv->show_zeroes && !visible))
+ return;
+ equation->priv->show_zeroes = visible;
+ reformat_display(equation, equation->priv->base);
+ g_object_notify(G_OBJECT(equation), "show-trailing-zeroes");
+}
+
+
+gboolean
+math_equation_get_show_trailing_zeroes(MathEquation *equation)
+{
+ return equation->priv->show_zeroes;
+}
+
+
+void
+math_equation_set_number_format(MathEquation *equation, DisplayFormat format)
+{
+ if (equation->priv->format == format)
+ return;
+
+ equation->priv->format = format;
+ reformat_display(equation, equation->priv->base);
+ g_object_notify(G_OBJECT(equation), "number-format");
+}
+
+
+DisplayFormat
+math_equation_get_number_format(MathEquation *equation)
+{
+ return equation->priv->format;
+}
+
+
+void
+math_equation_set_base(MathEquation *equation, gint base)
+{
+ gint old_base;
+
+ if (equation->priv->base == base)
+ return;
+
+ old_base = equation->priv->base;
+ equation->priv->base = base;
+ reformat_display(equation, old_base);
+ g_object_notify(G_OBJECT(equation), "base");
+}
+
+
+gint
+math_equation_get_base(MathEquation *equation)
+{
+ return equation->priv->base;
+}
+
+
+void
+math_equation_set_word_size(MathEquation *equation, gint word_size)
+{
+ if (equation->priv->word_size == word_size)
+ return;
+ equation->priv->word_size = word_size;
+ g_object_notify(G_OBJECT(equation), "word-size");
+}
+
+
+gint
+math_equation_get_word_size(MathEquation *equation)
+{
+ return equation->priv->word_size;
+}
+
+
+void
+math_equation_set_angle_units(MathEquation *equation, MPAngleUnit angle_units)
+{
+ if (equation->priv->angle_units == angle_units)
+ return;
+ equation->priv->angle_units = angle_units;
+ g_object_notify(G_OBJECT(equation), "angle-units");
+}
+
+
+MPAngleUnit
+math_equation_get_angle_units(MathEquation *equation)
+{
+ return equation->priv->angle_units;
+}
+
+
+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;
+
+ if (strcmp(equation->priv->source_currency, currency) == 0)
+ return;
+ g_free(equation->priv->source_currency);
+ equation->priv->source_currency = g_strdup(currency);
+ g_object_notify(G_OBJECT(equation), "source-currency");
+}
+
+const gchar *
+math_equation_get_source_currency(MathEquation *equation)
+{
+ return equation->priv->source_currency;
+}
+
+
+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;
+
+ if (strcmp(equation->priv->target_currency, currency) == 0)
+ return;
+ g_free(equation->priv->target_currency);
+ equation->priv->target_currency = g_strdup(currency);
+ g_object_notify(G_OBJECT(equation), "target-currency");
+}
+
+
+const gchar *
+math_equation_get_target_currency(MathEquation *equation)
+{
+ return equation->priv->target_currency;
+}
+
+
+void
+math_equation_set_status(MathEquation *equation, const gchar *status)
+{
+ 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");
+}
+
+
+const gchar *
+math_equation_get_status(MathEquation *equation)
+{
+ return equation->priv->state.status;
+}
+
+
+gboolean
+math_equation_is_empty(MathEquation *equation)
+{
+ return gtk_text_buffer_get_char_count(GTK_TEXT_BUFFER(equation)) == 0;
+}
+
+
+gboolean
+math_equation_is_result(MathEquation *equation)
+{
+ char *text;
+ gboolean result;
+
+ text = math_equation_get_equation(equation);
+ result = strcmp(text, "ans") == 0;
+ g_free(text);
+
+ return result;
+}
+
+
+gchar *
+math_equation_get_display(MathEquation *equation)
+{
+ GtkTextIter start, end;
+
+ gtk_text_buffer_get_bounds(GTK_TEXT_BUFFER(equation), &start, &end);
+ return gtk_text_buffer_get_text(GTK_TEXT_BUFFER(equation), &start, &end, FALSE);
+}
+
+
+gchar *
+math_equation_get_equation(MathEquation *equation)
+{
+ char *text, *t;
+ gint ans_start, ans_end;
+
+ text = math_equation_get_display(equation);
+
+ /* No ans to substitute */
+ if(!equation->priv->ans_start)
+ return text;
+
+ 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));
+ g_free(text);
+ return t;
+}
+
+
+gboolean
+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);
+
+ return result;
+}
+
+
+void
+math_equation_set_number_mode(MathEquation *equation, NumberMode mode)
+{
+ if (equation->priv->number_mode == mode)
+ return;
+
+ equation->priv->can_super_minus = mode == SUPERSCRIPT;
+
+ equation->priv->number_mode = mode;
+ g_object_notify(G_OBJECT(equation), "number-mode");
+}
+
+
+NumberMode
+math_equation_get_number_mode(MathEquation *equation)
+{
+ return equation->priv->number_mode;
+}
+
+
+const MPNumber *
+math_equation_get_answer(MathEquation *equation)
+{
+ return &equation->priv->state.ans;
+}
+
+
+void
+math_equation_store(MathEquation *equation, const gchar *name)
+{
+ MPNumber t;
+
+ 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);
+}
+
+
+void
+math_equation_recall(MathEquation *equation, const gchar *name)
+{
+ math_equation_insert(equation, name);
+}
+
+
+void
+math_equation_set(MathEquation *equation, const gchar *text)
+
+{
+ gtk_text_buffer_set_text(GTK_TEXT_BUFFER(equation), text, -1);
+ clear_ans(equation, FALSE);
+}
+
+
+void
+math_equation_set_number(MathEquation *equation, const MPNumber *x)
+{
+ char text[MAX_DIGITS];
+ GtkTextIter start, end;
+
+ /* Show the number in the user chosen format */
+ display_make_number(equation, text, MAX_DIGITS, x);
+ gtk_text_buffer_set_text(GTK_TEXT_BUFFER(equation), text, -1);
+ mp_set_from_mp(x, &equation->priv->state.ans);
+
+ /* Mark this text as the answer variable */
+ gtk_text_buffer_get_bounds(GTK_TEXT_BUFFER(equation), &start, &end);
+ clear_ans(equation, FALSE);
+ 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);
+}
+
+
+void
+math_equation_insert(MathEquation *equation, const gchar *text)
+{
+ /* 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) {
+ GtkTextIter iter;
+
+ gtk_text_buffer_get_iter_at_mark(GTK_TEXT_BUFFER(equation), &iter, gtk_text_buffer_get_insert(GTK_TEXT_BUFFER(equation)));
+ gtk_text_buffer_backspace(GTK_TEXT_BUFFER(equation), &iter, TRUE, TRUE);
+ gtk_text_buffer_insert_at_cursor(GTK_TEXT_BUFFER(equation), "^", -1);
+ 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;
+
+ /* Disable super/subscript mode when finished entering */
+ 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);
+}
+
+
+void
+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));
+ else if (equation->priv->number_mode == SUPERSCRIPT)
+ math_equation_insert(equation, superscript_digits[digit]);
+ else if (equation->priv->number_mode == SUBSCRIPT)
+ math_equation_insert(equation, subscript_digits[digit]);
+}
+
+
+void
+math_equation_insert_numeric_point(MathEquation *equation)
+{
+ math_equation_insert(equation, math_equation_get_numeric_point_text(equation));
+}
+
+
+void
+math_equation_insert_number(MathEquation *equation, const MPNumber *x)
+{
+ char text[MAX_DIGITS];
+ display_make_number(equation, text, MAX_DIGITS, x);
+ math_equation_insert(equation, text);
+}
+
+
+void
+math_equation_insert_exponent(MathEquation *equation)
+{
+ math_equation_insert(equation, "×10");
+ math_equation_set_number_mode(equation, SUPERSCRIPT);
+}
+
+
+void
+math_equation_insert_subtract(MathEquation *equation)
+{
+ if (equation->priv->number_mode == SUPERSCRIPT && equation->priv->can_super_minus) {
+ math_equation_insert(equation, "⁻");
+ equation->priv->can_super_minus = FALSE;
+ }
+ else {
+ math_equation_insert(equation, "−");
+ math_equation_set_number_mode(equation, NORMAL);
+ }
+}
+
+
+static int
+variable_is_defined(const char *name, void *data)
+{
+ MathEquation *equation = data;
+ char *c, *lower_name;
+
+ lower_name = strdup(name);
+ for (c = lower_name; *c; c++)
+ *c = tolower(*c);
+
+ if (strcmp(lower_name, "rand") == 0 ||
+ strcmp(lower_name, "ans") == 0) {
+ g_free (lower_name);
+ return 1;
+ }
+ g_free (lower_name);
+
+ return math_variables_get_value(equation->priv->variables, name) != NULL;
+}
+
+
+static int
+get_variable(const char *name, MPNumber *z, void *data)
+{
+ char *c, *lower_name;
+ int result = 1;
+ MathEquation *equation = data;
+ MPNumber *t;
+
+ lower_name = strdup(name);
+ for (c = lower_name; *c; c++)
+ *c = tolower(*c);
+
+ if (strcmp(lower_name, "rand") == 0)
+ mp_set_from_random(z);
+ 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);
+ if (t)
+ mp_set_from_mp(t, z);
+ else
+ result = 0;
+ }
+
+ free(lower_name);
+
+ return result;
+}
+
+
+static void
+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);
+}
+
+
+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);
+}
+
+
+static int
+parse(MathEquation *equation, const char *text, MPNumber *z, char **error_token)
+{
+ MPEquationOptions options;
+
+ memset(&options, 0, sizeof(options));
+ options.base = equation->priv->base;
+ options.wordlen = equation->priv->word_size;
+ options.angle_units = equation->priv->angle_units;
+ options.variable_is_defined = variable_is_defined;
+ options.get_variable = get_variable;
+ options.set_variable = set_variable;
+ options.convert = convert;
+ options.callback_data = equation;
+
+ return mp_equation_parse(text, &options, z, error_token);
+}
+
+
+void
+math_equation_solve(MathEquation *equation)
+{
+ 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;
+ }
+
+ math_equation_set_number_mode(equation, NORMAL);
+
+ text = math_equation_get_equation(equation);
+ equation_text = g_string_new(text);
+ g_free(text);
+ /* Count the number of brackets and automatically add missing closing brackets */
+ for (c = equation_text->str; *c; c++) {
+ if (*c == '(')
+ n_brackets++;
+ else if (*c == ')')
+ n_brackets--;
+ }
+ while (n_brackets > 0) {
+ g_string_append_c(equation_text, ')');
+ n_brackets--;
+ }
+
+
+ result = parse(equation, equation_text->str, &z, &error_token);
+ g_string_free(equation_text, TRUE);
+
+ switch (result) {
+ case PARSER_ERR_NONE:
+ math_equation_set_number(equation, &z);
+ 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 */
+ _("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 */
+ _("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 */
+ _("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 */
+ _("Unknown conversion"));
+ break;
+
+ case PARSER_ERR_MP:
+ message = g_strdup(mp_get_error());
+ break;
+
+ default:
+ message = g_strdup(/* Error displayed to user when they enter an invalid calculation */
+ _("Malformed expression"));
+ break;
+ }
+
+ if (error_token)
+ free(error_token);
+
+ if (message) {
+ math_equation_set_status(equation, message);
+ g_free(message);
+ }
+}
+
+
+void
+math_equation_factorize(MathEquation *equation)
+{
+ MPNumber x;
+ GList *factors, *factor;
+ GString *text;
+
+ 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;
+ }
+
+ factors = mp_factorize(&x);
+
+ text = g_string_new("");
+
+ for (factor = factors; factor; factor = factor->next) {
+ gchar temp[MAX_DIGITS];
+ MPNumber *n;
+
+ n = factor->data;
+ display_make_number(equation, temp, MAX_DIGITS, n);
+ g_string_append(text, temp);
+ if (factor->next)
+ g_string_append(text, "×");
+ g_slice_free(MPNumber, n);
+ }
+ g_list_free(factors);
+
+ math_equation_set(equation, text->str);
+ g_string_free(text, TRUE);
+}
+
+
+void
+math_equation_delete(MathEquation *equation)
+{
+ gint cursor;
+ GtkTextIter start, end;
+
+ g_object_get(G_OBJECT(equation), "cursor-position", &cursor, NULL);
+ if (cursor >= gtk_text_buffer_get_char_count(GTK_TEXT_BUFFER(equation)))
+ return;
+
+ gtk_text_buffer_get_iter_at_offset(GTK_TEXT_BUFFER(equation), &start, cursor);
+ gtk_text_buffer_get_iter_at_offset(GTK_TEXT_BUFFER(equation), &end, cursor+1);
+ gtk_text_buffer_delete(GTK_TEXT_BUFFER(equation), &start, &end);
+}
+
+
+void
+math_equation_backspace(MathEquation *equation)
+{
+ /* Can't delete empty display */
+ if (math_equation_is_empty(equation))
+ return;
+
+ if (gtk_text_buffer_get_has_selection(GTK_TEXT_BUFFER(equation)))
+ gtk_text_buffer_delete_selection(GTK_TEXT_BUFFER(equation), FALSE, FALSE);
+ else {
+ GtkTextIter iter;
+ gtk_text_buffer_get_iter_at_mark(GTK_TEXT_BUFFER(equation), &iter, gtk_text_buffer_get_insert(GTK_TEXT_BUFFER(equation)));
+ gtk_text_buffer_backspace(GTK_TEXT_BUFFER(equation), &iter, TRUE, TRUE);
+ }
+}
+
+
+void
+math_equation_clear(MathEquation *equation)
+{
+ math_equation_set_number_mode(equation, NORMAL);
+ gtk_text_buffer_set_text(GTK_TEXT_BUFFER(equation), "", -1);
+ clear_ans(equation, FALSE);
+}
+
+
+void
+math_equation_shift(MathEquation *equation, gint count)
+{
+ MPNumber z;
+
+ if (!math_equation_get_number(equation, &z)) {
+ math_equation_set_status(equation,
+ /* This message is displayed in the status bar when a bit
+ shift operation is performed and the display does not contain a number */
+ _("No sane value to bitwise shift"));
+ return;
+ }
+
+ mp_shift(&z, count, &z);
+ math_equation_set_number(equation, &z);
+}
+
+
+void
+math_equation_toggle_bit(MathEquation *equation, guint bit)
+{
+ MPNumber x;
+ guint64 bits;
+ gboolean result;
+
+ result = math_equation_get_number(equation, &x);
+ if (result) {
+ MPNumber max;
+ mp_set_from_unsigned_integer(G_MAXUINT64, &max);
+ if (mp_is_negative(&x) || mp_is_greater_than(&x, &max))
+ result = FALSE;
+ else
+ bits = mp_cast_to_unsigned_int(&x);
+ }
+
+ if (!result) {
+ math_equation_set_status(equation,
+ /* Message displayed when cannot toggle bit in display*/
+ _("Displayed value not an integer"));
+ return;
+ }
+
+ bits ^= (1LL << (63 - bit));
+
+ mp_set_from_unsigned_integer(bits, &x);
+
+ // FIXME: Only do this if in ans format, otherwise set text in same format as previous number
+ math_equation_set_number(equation, &x);
+}
+
+
+/* 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,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ MathEquation *self;
+
+ self = MATH_EQUATION (object);
+
+ switch (prop_id) {
+ case PROP_STATUS:
+ math_equation_set_status(self, g_value_get_string(value));
+ break;
+ case PROP_DISPLAY:
+ math_equation_set(self, g_value_get_string(value));
+ break;
+ case PROP_NUMBER_MODE:
+ math_equation_set_number_mode(self, g_value_get_int(value));
+ break;
+ case PROP_ACCURACY:
+ math_equation_set_accuracy(self, g_value_get_int(value));
+ break;
+ case PROP_SHOW_THOUSANDS_SEPARATORS:
+ math_equation_set_show_thousands_separators(self, g_value_get_boolean(value));
+ break;
+ case PROP_SHOW_TRAILING_ZEROES:
+ math_equation_set_show_trailing_zeroes(self, g_value_get_boolean(value));
+ break;
+ case PROP_NUMBER_FORMAT:
+ math_equation_set_number_format(self, g_value_get_int(value));
+ break;
+ case PROP_BASE:
+ math_equation_set_base(self, g_value_get_int(value));
+ break;
+ case PROP_WORD_SIZE:
+ math_equation_set_word_size(self, g_value_get_int(value));
+ break;
+ case PROP_ANGLE_UNITS:
+ math_equation_set_angle_units(self, g_value_get_int(value));
+ break;
+ case PROP_SOURCE_CURRENCY:
+ math_equation_set_source_currency(self, g_value_get_string(value));
+ break;
+ case PROP_TARGET_CURRENCY:
+ math_equation_set_target_currency(self, g_value_get_string(value));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+
+static void
+math_equation_get_property(GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ MathEquation *self;
+ gchar *text;
+
+ 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);
+ g_value_set_string(value, text);
+ g_free(text);
+ break;
+ case PROP_EQUATION:
+ text = math_equation_get_equation(self);
+ g_value_set_string(value, text);
+ g_free(text);
+ break;
+ case PROP_NUMBER_MODE:
+ g_value_set_enum(value, self->priv->number_mode);
+ break;
+ case PROP_ACCURACY:
+ g_value_set_int(value, self->priv->accuracy);
+ break;
+ case PROP_SHOW_THOUSANDS_SEPARATORS:
+ g_value_set_boolean(value, self->priv->show_tsep);
+ break;
+ case PROP_SHOW_TRAILING_ZEROES:
+ g_value_set_boolean(value, self->priv->show_zeroes);
+ break;
+ case PROP_NUMBER_FORMAT:
+ g_value_set_enum(value, self->priv->format);
+ break;
+ case PROP_BASE:
+ g_value_set_int(value, math_equation_get_base(self));
+ break;
+ case PROP_WORD_SIZE:
+ g_value_set_int(value, self->priv->word_size);
+ break;
+ case PROP_ANGLE_UNITS:
+ g_value_set_enum(value, self->priv->angle_units);
+ break;
+ case PROP_SOURCE_CURRENCY:
+ g_value_set_string(value, self->priv->source_currency);
+ break;
+ case PROP_TARGET_CURRENCY:
+ g_value_set_string(value, self->priv->target_currency);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+
+static void
+math_equation_class_init (MathEquationClass *klass)
+{
+ static GEnumValue number_mode_values[] =
+ {
+ {NORMAL, "normal", "normal"},
+ {SUPERSCRIPT, "superscript", "superscript"},
+ {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"},
+ {MP_DEGREES, "degrees", "degrees"},
+ {MP_GRADIANS, "gradians", "gradians"},
+ {0, NULL, NULL}
+ };
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+ object_class->get_property = math_equation_get_property;
+ object_class->set_property = math_equation_set_property;
+
+ 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);
+ angle_unit_type = g_enum_register_static("AngleUnit", angle_unit_values);
+
+ g_object_class_install_property(object_class,
+ PROP_STATUS,
+ g_param_spec_string("status",
+ "status",
+ "Equation status",
+ "",
+ G_PARAM_READWRITE));
+ g_object_class_install_property(object_class,
+ PROP_DISPLAY,
+ g_param_spec_string("display",
+ "display",
+ "Displayed equation text",
+ "",
+ G_PARAM_READWRITE));
+ g_object_class_install_property(object_class,
+ PROP_EQUATION,
+ g_param_spec_string("equation",
+ "equation",
+ "Equation text",
+ "",
+ G_PARAM_READABLE));
+ g_object_class_install_property(object_class,
+ PROP_NUMBER_MODE,
+ g_param_spec_enum("number-mode",
+ "number-mode",
+ "Input number mode",
+ number_mode_type,
+ NORMAL,
+ G_PARAM_READWRITE));
+ g_object_class_install_property(object_class,
+ PROP_ACCURACY,
+ g_param_spec_int("accuracy",
+ "accuracy",
+ "Display accuracy",
+ 0, 20, 9,
+ G_PARAM_READWRITE));
+ g_object_class_install_property(object_class,
+ PROP_SHOW_THOUSANDS_SEPARATORS,
+ g_param_spec_boolean("show-thousands-separators",
+ "show-thousands-separators",
+ "Show thousands separators",
+ TRUE,
+ G_PARAM_READWRITE));
+ g_object_class_install_property(object_class,
+ PROP_SHOW_TRAILING_ZEROES,
+ g_param_spec_boolean("show-trailing-zeroes",
+ "show-trailing-zeroes",
+ "Show trailing zeroes",
+ FALSE,
+ G_PARAM_READWRITE));
+ g_object_class_install_property(object_class,
+ PROP_NUMBER_FORMAT,
+ g_param_spec_enum("number-format",
+ "number-format",
+ "Display format",
+ number_format_type,
+ FIX,
+ 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,
+ G_PARAM_READWRITE));
+ g_object_class_install_property(object_class,
+ PROP_WORD_SIZE,
+ g_param_spec_int("word-size",
+ "word-size",
+ "Word size in bits",
+ 8, 64, 64,
+ G_PARAM_READWRITE));
+ g_object_class_install_property(object_class,
+ PROP_ANGLE_UNITS,
+ g_param_spec_enum("angle-units",
+ "angle-units",
+ "Angle units",
+ angle_unit_type,
+ MP_DEGREES,
+ G_PARAM_READWRITE));
+ g_object_class_install_property(object_class,
+ PROP_SOURCE_CURRENCY,
+ g_param_spec_string("source-currency",
+ "source-currency",
+ "Source Currency",
+ "",
+ G_PARAM_READWRITE));
+ g_object_class_install_property(object_class,
+ PROP_TARGET_CURRENCY,
+ g_param_spec_string("target-currency",
+ "target-currency",
+ "target Currency",
+ "",
+ G_PARAM_READWRITE));
+}
+
+
+static void
+pre_insert_text_cb (MathEquation *equation,
+ GtkTextIter *location,
+ gchar *text,
+ gint len,
+ gpointer user_data)
+{
+ gunichar c;
+
+ 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)) {
+ 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);
+ }
+
+ if (equation->priv->ans_start) {
+ gint ans_start, ans_end;
+ gint offset;
+
+ 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);
+ }
+}
+
+
+static gboolean
+on_delete(MathEquation *equation)
+{
+ equation->priv->in_delete = FALSE;
+ return FALSE;
+}
+
+
+static void
+pre_delete_range_cb (MathEquation *equation,
+ GtkTextIter *start,
+ GtkTextIter *end,
+ gpointer user_data)
+{
+ if (equation->priv->in_reformat)
+ return;
+
+ math_equation_push_undo_stack(equation);
+
+ equation->priv->in_delete = TRUE;
+ g_idle_add((GSourceFunc)on_delete, equation);
+
+ if (equation->priv->ans_start) {
+ gint ans_start, ans_end;
+ gint start_offset, end_offset;
+
+ 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);
+ }
+}
+
+
+static void
+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;
+ g_object_notify(G_OBJECT(equation), "display");
+}
+
+
+static void
+delete_range_cb (MathEquation *equation,
+ GtkTextIter *start,
+ GtkTextIter *end,
+ gpointer user_data)
+{
+ if (equation->priv->in_reformat)
+ return;
+
+ // FIXME: A replace will emit this both for delete-range and insert-text, can it be avoided?
+ g_object_notify(G_OBJECT(equation), "display");
+}
+
+
+static void
+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;
+ 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);
+
+ 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_after(equation, "insert-text", G_CALLBACK(insert_text_cb), equation);
+ g_signal_connect_after(equation, "delete-range", G_CALLBACK(delete_range_cb), equation);
+
+ digits = g_strsplit(digit_values, ",", -1);
+ 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]);
+ }
+ else
+ equation->priv->digits[i] = strdup(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;
+
+ mp_set_from_integer(0, &equation->priv->state.ans);
+}