G_DEFINE_TYPE_WITH_PRIVATE (CurrencyManager, currency_manager, G_TYPE_OBJECT);

enum {

UPDATED,

LAST_SIGNAL

static CurrencyManager *default_currency_manager = NULL;

CurrencyManager *

currency_manager_get_default(void)

{

return default_currency_manager;

}

GList *

currency_manager_get_currencies(CurrencyManager *manager)

{

return manager->priv->currencies;

}

Currency *

currency_manager_get_currency(CurrencyManager *manager, const gchar *name)

{

return NULL;

}

static char *

get_imf_rate_filepath(void)

{

NULL);

}

static char *

get_ecb_rate_filepath(void)

{

NULL);

}

static Currency *

add_currency(CurrencyManager *manager, const gchar *short_name)

{

return c;

}

/* A file needs to be redownloaded if it doesn't exist, or is too old.

* When an error occur, it probably won't hurt to try to download again.

*/

return FALSE;

}

static void

download_imf_cb(GObject *object, GAsyncResult *result, gpointer user_data)

{

load_rates(manager);

}

static void

download_ecb_cb(GObject *object, GAsyncResult *result, gpointer user_data)

{

load_rates(manager);

}

static void

download_file(CurrencyManager *manager, gchar *uri, gchar *filename, GAsyncReadyCallback callback)

{

g_object_unref(dest);

}

static void

load_imf_rates(CurrencyManager *manager)

{

g_strfreev(lines);

}

static void

set_ecb_rate(CurrencyManager *manager, xmlNodePtr node, Currency *eur_rate)

{

xmlFree(value);

}

static void

set_ecb_fixed_rate(CurrencyManager *manager, const gchar *name, const gchar *value, Currency *eur_rate)

{

mp_clear(&v);

}

static void

load_ecb_rates(CurrencyManager *manager)

{

xmlCleanupParser();

}

static gboolean

load_rates(CurrencyManager *manager)

{

return TRUE;

}

const MPNumber *

currency_manager_get_value(CurrencyManager *manager, const gchar *currency)

{

return NULL;

}

static void

currency_manager_class_init(CurrencyManagerClass *klass)

{

G_TYPE_NONE, 0);

}

static void

currency_manager_init(CurrencyManager *manager)

{

G_DEFINE_TYPE_WITH_PRIVATE (Currency, currency, G_TYPE_OBJECT);

Currency *

currency_new(const gchar *name,

const gchar *display_name,

return currency;

}

const gchar *

currency_get_name(Currency *currency)

{

return currency->priv->name;

}

const gchar *

currency_get_display_name(Currency *currency)

{

return currency->priv->display_name;

}

const gchar *

currency_get_symbol(Currency *currency)

{

return currency->priv->symbol;

}

void

currency_set_value(Currency *currency, MPNumber *value)

{

mp_set_from_mp (value, &currency->priv->value);

}

const MPNumber *

currency_get_value(Currency *currency)

{

return &currency->priv->value;

}

static void

currency_class_init(CurrencyClass *klass)

{

}

static void

currency_init(Currency *currency)

{

mp_clear(&MP4);

}

static void

calc_ddb(MathEquation *equation, MPNumber *t, MPNumber *cost, MPNumber *life, MPNumber *period)

{

mp_clear(&MP2);

}

static void

calc_fv(MPNumber *t, MPNumber *pmt, MPNumber *pint, MPNumber *n)

{

mp_clear(&MP4);

}

static void

calc_gpm(MPNumber *t, MPNumber *cost, MPNumber *margin)

{

mp_clear(&MP2);

}

static void

calc_pmt(MPNumber *t, MPNumber *prin, MPNumber *pint, MPNumber *n)

{

mp_clear(&MP4);

}

static void

calc_pv(MPNumber *t, MPNumber *pmt, MPNumber *pint, MPNumber *n)

{

mp_clear(&MP4);

}

static void

calc_rate(MPNumber *t, MPNumber *fv, MPNumber *pv, MPNumber *n)

{

mp_clear(&MP4);

}

static void

calc_sln(MPNumber *t, MPNumber *cost, MPNumber *salvage, MPNumber *life)

{

mp_clear(&MP1);

}

static void

calc_syd(MPNumber *t, MPNumber *cost, MPNumber *salvage, MPNumber *life, MPNumber *period)

{

mp_clear(&MP4);

}

static void

calc_term(MPNumber *t, MPNumber *pmt, MPNumber *fv, MPNumber *pint)

{

mp_clear(&MP4);

}

void

do_finc_expression(MathEquation *equation, int function, MPNumber *arg1, MPNumber *arg2, MPNumber *arg3, MPNumber *arg4)

{

mp_clear(&z);

}

/* Adjust user input equation string before solving it. */

static void

str_adjust(char *str)

fprintf(stderr, "%1$s %2$s\n", progname, VERSION);

}

static int

do_convert(const MPNumber *x, const char *x_units, const char *z_units, MPNumber *z, void *data)

{

return unit_manager_convert_by_symbol(unit_manager_get_default(), x, x_units, z_units, z);

}

static void

solve(const char *equation)

{

}

}

static void

usage(const gchar *progname, gboolean show_application, gboolean show_gtk)

{

}

}

static void

get_options(int argc, char *argv[])

{

{NULL, NULL, NULL, NULL, NULL}

};

MathButtons *

math_buttons_new(MathEquation *equation)

{

g_object_set_data(object, name, GINT_TO_POINTER(value));

}

static void

set_int_data(GtkBuilder *ui, const gchar *object_name, const gchar *name, gint value)

{

g_object_set_data(object, name, GINT_TO_POINTER(value));

}

static void

load_finc_dialogs(MathButtons *buttons)

{

}

}

static void

update_bit_panel(MathButtons *buttons)

{

mp_clear(&x);

}

static void

display_changed_cb(MathEquation *equation, GParamSpec *spec, MathButtons *buttons)

{

update_bit_panel(buttons);

}

static void

base_combobox_changed_cb(GtkWidget *combo, MathButtons *buttons)

{

math_buttons_set_programming_base(buttons, value);

}

static void

base_changed_cb(MathEquation *equation, GParamSpec *spec, MathButtons *buttons)

{

gtk_combo_box_set_active_iter(GTK_COMBO_BOX(buttons->priv->base_combo), &iter);

}

static GtkWidget *

load_mode(MathButtons *buttons, ButtonMode mode)

{

return *panel;

}

static void

converter_changed_cb(MathConverter *converter, MathButtons *buttons)

{

g_object_unref(to_unit);

}

static void

load_buttons(MathButtons *buttons)

{

gtk_widget_show(panel);

}

void

math_buttons_set_mode(MathButtons *buttons, ButtonMode mode)

{

g_object_notify(G_OBJECT(buttons), "mode");

}

ButtonMode

math_buttons_get_mode(MathButtons *buttons)

{

return buttons->priv->mode;

}

void

math_buttons_set_programming_base(MathButtons *buttons, gint base)

{

math_equation_set_base(buttons->priv->equation, base);

}

gint

math_buttons_get_programming_base(MathButtons *buttons)

{

return buttons->priv->programming_base;

}

void exponent_cb(GtkWidget *widget, MathButtons *buttons);

G_MODULE_EXPORT

void

math_equation_insert_exponent(buttons->priv->equation);

}

void subtract_cb(GtkWidget *widget, MathButtons *buttons);

G_MODULE_EXPORT

void

math_equation_insert_subtract(buttons->priv->equation);

}

void button_cb(GtkWidget *widget, MathButtons *buttons);

G_MODULE_EXPORT

void

math_equation_insert(buttons->priv->equation, g_object_get_data(G_OBJECT(widget), "calc_text"));

}

void solve_cb(GtkWidget *widget, MathButtons *buttons);

G_MODULE_EXPORT

void

math_equation_solve(buttons->priv->equation);

}

void clear_cb(GtkWidget *widget, MathButtons *buttons);

G_MODULE_EXPORT

void

math_equation_clear(buttons->priv->equation);

}

void delete_cb(GtkWidget *widget, MathButtons *buttons);

G_MODULE_EXPORT

void

math_equation_delete(buttons->priv->equation);

}

void undo_cb(GtkWidget *widget, MathButtons *buttons);

G_MODULE_EXPORT

void

math_equation_undo(buttons->priv->equation);

}

static void

shift_cb(GtkWidget *widget, MathButtons *buttons)

{

NULL);

}

void memory_cb(GtkWidget *widget, MathButtons *buttons);

G_MODULE_EXPORT

void

gtk_widget_show(GTK_WIDGET(popup));

}

void shift_left_cb(GtkWidget *widget, MathButtons *buttons);

G_MODULE_EXPORT

void

popup_button_menu(widget, GTK_MENU(buttons->priv->shift_left_menu));

}

void shift_right_cb(GtkWidget *widget, MathButtons *buttons);

G_MODULE_EXPORT

void

popup_button_menu(widget, GTK_MENU(buttons->priv->shift_right_menu));

}

static void

insert_function_cb(GtkWidget *widget, MathButtons *buttons)

{

math_equation_insert(buttons->priv->equation, g_object_get_data(G_OBJECT(widget), "function"));

}

void function_cb(GtkWidget *widget, MathButtons *buttons);

G_MODULE_EXPORT

void

math_equation_insert(buttons->priv->equation, g_object_get_data(G_OBJECT(widget), "const"));

}

void const_cb(GtkWidget *widget, MathButtons *buttons);

G_MODULE_EXPORT

void

math_equation_factorize(buttons->priv->equation);

}

void digit_cb(GtkWidget *widget, MathButtons *buttons);

G_MODULE_EXPORT

void

math_equation_insert_digit(buttons->priv->equation, GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), "calc_digit")));

}

void numeric_point_cb(GtkWidget *widget, MathButtons *buttons);

G_MODULE_EXPORT

void

math_equation_insert_numeric_point(buttons->priv->equation);

}

void finc_cb(GtkWidget *widget, MathButtons *buttons);

G_MODULE_EXPORT

void

gtk_widget_hide(GTK_WIDGET(GET_WIDGET(buttons->priv->financial_ui, name)));

}

void insert_character_code_cb(GtkWidget *widget, MathButtons *buttons);

G_MODULE_EXPORT

void

gtk_window_present(GTK_WINDOW(buttons->priv->character_code_dialog));

}

void finc_activate_cb(GtkWidget *widget, MathButtons *buttons);

G_MODULE_EXPORT

void

}

}

void finc_response_cb(GtkWidget *widget, gint response_id, MathButtons *buttons);

G_MODULE_EXPORT

void

}

}

void character_code_dialog_response_cb(GtkWidget *dialog, gint response_id, MathButtons *buttons);

G_MODULE_EXPORT

void

gtk_widget_hide(dialog);

}

void character_code_dialog_activate_cb(GtkWidget *entry, MathButtons *buttons);

G_MODULE_EXPORT

void

character_code_dialog_response_cb(buttons->priv->character_code_dialog, GTK_RESPONSE_OK, buttons);

}

gboolean character_code_dialog_delete_cb(GtkWidget *dialog, GdkEvent *event, MathButtons *buttons);

G_MODULE_EXPORT

gboolean

return TRUE;

}

gboolean bit_toggle_cb(GtkWidget *event_box, GdkEventButton *event, MathButtons *buttons);

G_MODULE_EXPORT

gboolean

return TRUE;

}

static void

remove_trailing_spaces(MathButtons *buttons)

{

}

}

void set_superscript_cb(GtkWidget *widget, MathButtons *buttons);

G_MODULE_EXPORT

void

math_equation_set_number_mode(buttons->priv->equation, NORMAL);

}

void set_subscript_cb(GtkWidget *widget, MathButtons *buttons);

G_MODULE_EXPORT

void

math_equation_set_number_mode(buttons->priv->equation, NORMAL);

}

static void

number_mode_changed_cb(MathEquation *equation, GParamSpec *spec, MathButtons *buttons)

{

}

}

static void

math_buttons_set_property(GObject *object,

guint prop_id,

}

}

static void

math_buttons_get_property(GObject *object,

guint prop_id,

}

}

static void

math_buttons_class_init(MathButtonsClass *klass)

{

G_PARAM_READWRITE));

}

static void

math_buttons_init(MathButtons *buttons)

{

GtkWidget *result_label;

};

G_DEFINE_TYPE_WITH_PRIVATE (MathConverter, math_converter, GTK_TYPE_BOX);

static void display_changed_cb(MathEquation *equation, GParamSpec *spec, MathConverter *converter);

static void update_from_model(MathConverter *converter);

MathConverter *

math_converter_new(MathEquation *equation)

{

return converter;

}

static gboolean

convert_equation(MathConverter *converter, const MPNumber *x, MPNumber *z)

{

return result;

}

static void

update_result_label(MathConverter *converter)

{

mp_clear(&z);

}

static void

display_changed_cb(MathEquation *equation, GParamSpec *spec, MathConverter *converter)

{

update_result_label(converter);

}

static void

update_from_model(MathConverter *converter)

{

gtk_combo_box_set_model(GTK_COMBO_BOX(converter->priv->from_combo), GTK_TREE_MODEL(from_model));

}

void

math_converter_set_category(MathConverter *converter, const gchar *category)

{

update_from_model(converter);

}

const gchar *

math_converter_get_category(MathConverter *converter)

{

return converter->priv->category;

}

static gboolean

iter_is_unit(GtkTreeModel *model, GtkTreeIter *iter, const Unit *unit)

{

return FALSE;

}

static gboolean

set_active_unit(GtkComboBox *combo, GtkTreeIter *iter, Unit *unit)

{

return FALSE;

}

void

math_converter_set_conversion(MathConverter *converter, /*const gchar *category,*/ const gchar *unit_a, const gchar *unit_b)

{

set_active_unit(GTK_COMBO_BOX(converter->priv->to_combo), NULL, ub);

}

void

math_converter_get_conversion(MathConverter *converter, Unit **from_unit, Unit **to_unit)

{

gtk_tree_model_get(gtk_combo_box_get_model(GTK_COMBO_BOX(converter->priv->to_combo)), &to_iter, 2, to_unit, -1);

}

static void

math_converter_class_init(MathConverterClass *klass)

{

G_TYPE_NONE, 0);

}

static void

from_combobox_changed_cb(GtkWidget *combo, MathConverter *converter)

{

g_object_unref(unit);

}

static void

to_combobox_changed_cb(GtkWidget *combo, MathConverter *converter)

{

g_signal_emit(converter, signals[CHANGED], 0);

}

static void

from_cell_data_func(GtkCellLayout *cell_layout,

GtkCellRenderer *cell,

g_object_set(cell, "sensitive", !gtk_tree_model_iter_has_child(tree_model, iter), NULL);

}

static void

currency_updated_cb(CurrencyManager *manager, MathConverter *converter)

{

return g_object_new(math_display_get_type(), "equation", math_equation_new(), NULL);

}

MathDisplay *

math_display_new_with_equation(MathEquation *equation)

{

return g_object_new(math_display_get_type(), "equation", equation, NULL);

}

MathEquation *

math_display_get_equation(MathDisplay *display)

{

return display->priv->equation;

}

static gboolean

display_key_press_cb(GtkWidget *widget, GdkEventKey *event, MathDisplay *display)

{

return FALSE;

}

static gboolean

key_press_cb(MathDisplay *display, GdkEventKey *event)

{

return result;

}

static void

status_changed_cb(MathEquation *equation, GParamSpec *spec, MathDisplay *display)

{

status_changed_cb(display->priv->equation, NULL, display);

}

static void

math_display_set_property(GObject *object,

guint prop_id,

}

}

static void

math_display_get_property(GObject *object,

guint prop_id,

}

}

static void

math_display_class_init(MathDisplayClass *klass)

{

G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));

}

static void

math_display_init(MathDisplay *display)

{

G_DEFINE_TYPE_WITH_PRIVATE (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)

{

*end = gtk_text_iter_get_offset(&iter);

}

static void

reformat_ans(MathEquation *equation)

{

g_free(ans_text);

}

static gint

count_digits(MathEquation *equation, const gchar *text)

{

return count;

}

static void

reformat_separators(MathEquation *equation)

{

equation->priv->in_undo_operation = FALSE;

}

static void

reformat_display(MathEquation *equation)

{

g_signal_emit_by_name(equation, "display-changed");

}

static MathEquationState *

get_current_state(MathEquation *equation)

{

return state;

}

static void

free_state(MathEquationState *state)

{

g_free(state);

}

static void

math_equation_push_undo_stack(MathEquation *equation)

{

equation->priv->undo_stack = g_list_prepend(equation->priv->undo_stack, state);

}

static void

clear_ans(MathEquation *equation, gboolean remove_tag)

{

equation->priv->ans_end = NULL;

}

static void

apply_state(MathEquation *equation, MathEquationState *state)

{

equation->priv->in_undo_operation = FALSE;

}

void

math_equation_copy(MathEquation *equation)

{

g_free(text);

}

static void

on_paste(GtkClipboard *clipboard, const gchar *text, gpointer 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)

{

free_state(state);

}

void

math_equation_redo(MathEquation *equation)

{

free_state(state);

}

gunichar

math_equation_get_digit_text(MathEquation *equation, guint digit)

{

return equation->priv->digits[digit];

}

void

math_equation_set_accuracy(MathEquation *equation, gint accuracy)

{

g_object_notify(G_OBJECT(equation), "accuracy");

}

gint

math_equation_get_accuracy(MathEquation *equation)

{

return mp_serializer_get_trailing_digits(equation->priv->serializer);

}

void

math_equation_set_show_thousands_separators(MathEquation *equation, gboolean visible)

{

g_object_notify(G_OBJECT(equation), "show-thousands-separators");

}

gboolean

math_equation_get_show_thousands_separators(MathEquation *equation)

{

return mp_serializer_get_show_thousands_separators(equation->priv->serializer);

}

void

math_equation_set_show_trailing_zeroes(MathEquation *equation, gboolean visible)

{

g_object_notify(G_OBJECT(equation), "show-trailing-zeroes");

}

gboolean

math_equation_get_show_trailing_zeroes(MathEquation *equation)

{

return mp_serializer_get_show_trailing_zeroes(equation->priv->serializer);

}

void

math_equation_set_number_format(MathEquation *equation, MpDisplayFormat format)

{

g_object_notify(G_OBJECT(equation), "number-format");

}

MpDisplayFormat

math_equation_get_number_format(MathEquation *equation)

{

return mp_serializer_get_number_format(equation->priv->serializer);

}

void

math_equation_set_base(MathEquation *equation, gint base)

{

g_object_notify(G_OBJECT(equation), "base");

}

gint

math_equation_get_base(MathEquation *equation)

{

return mp_serializer_get_base(equation->priv->serializer);

}

void

math_equation_set_word_size(MathEquation *equation, gint 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)

{

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)

{

math_equation_get_source_currency(equation));

}

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)

{

math_equation_get_target_currency(equation));

}

const gchar *

math_equation_get_target_currency(MathEquation *equation)

{

return equation->priv->target_currency;

}

void

math_equation_set_source_units(MathEquation *equation, const gchar *units)

{

return equation->priv->source_units;

}

void

math_equation_set_target_units(MathEquation *equation, const gchar *units)

{

math_equation_get_target_units(equation));

}

const gchar *

math_equation_get_target_units(MathEquation *equation)

{

return equation->priv->target_units;

}

void

math_equation_set_status(MathEquation *equation, const gchar *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)

{

return result;

}

gchar *

math_equation_get_display(MathEquation *equation)

{

return gtk_text_buffer_get_text(GTK_TEXT_BUFFER(equation), &start, &end, FALSE);

}

gchar *

math_equation_get_equation(MathEquation *equation)

{

return text;

}

gboolean

math_equation_get_number(MathEquation *equation, MPNumber *z)

{

}

}

MpSerializer *

math_equation_get_serializer(MathEquation *equation)

{

return equation->priv->serializer;

}

void

math_equation_set_number_mode(MathEquation *equation, NumberMode mode)

{

g_object_notify(G_OBJECT(equation), "number-mode");

}

NumberMode

math_equation_get_number_mode(MathEquation *equation)

{

return equation->priv->number_mode;

}

gboolean

math_equation_in_solve(MathEquation *equation)

{

return equation->priv->in_solve;

}

const MPNumber *

math_equation_get_answer(MathEquation *equation)

{

return &equation->priv->state.ans;

}

void

math_equation_store(MathEquation *equation, const gchar *name)

{

mp_clear(&t);

}

void

math_equation_recall(MathEquation *equation, const gchar *name)

{

math_equation_insert(equation, name);

}

void

math_equation_set(MathEquation *equation, const gchar *text)

{

mp_clear(&x);

}

void

math_equation_set_number(MathEquation *equation, const MPNumber *x)

{

free_state(state);

}

void

math_equation_insert(MathEquation *equation, const gchar *text)

{

gtk_text_buffer_insert_at_cursor(GTK_TEXT_BUFFER(equation), text, -1);

}

void

math_equation_insert_digit(MathEquation *equation, guint digit)

{

math_equation_insert(equation, subscript_digits[digit]);

}

void

math_equation_insert_numeric_point(MathEquation *equation)

{

math_equation_insert(equation, buffer);

}

void

math_equation_insert_number(MathEquation *equation, const MPNumber *x)

{

g_free(text);

}

void

math_equation_insert_exponent(MathEquation *equation)

{

math_equation_set_number_mode(equation, SUPERSCRIPT);

}

void

math_equation_insert_subtract(MathEquation *equation)

{

}

}

static int

variable_is_defined(const char *name, void *data)

{

return math_variables_get(equation->priv->variables, name) != NULL;

}

static int

get_variable(const char *name, MPNumber *z, void *data)

{

return result;

}

static void

set_variable(const char *name, const MPNumber *x, void *data)

{

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 unit_manager_convert_by_symbol(unit_manager_get_default(), x, x_units, z_units, z);

}

static int

parse(MathEquation *equation, const char *text, MPNumber *z, char **error_token)

{

return mp_equation_parse(text, &options, z, error_token);

}

/*

* Executed in separate thread. It is thus not a good idea to write to anything

* in MathEquation but the async queue from here.

n_brackets--;

}

result = parse(equation, equation_text->str, &z, &error_token);

g_string_free(equation_text, TRUE);

return NULL;

}

static gboolean

math_equation_show_in_progress(gpointer data)

{

return false;

}

static gboolean

math_equation_look_for_answer(gpointer data)

{

return false;

}

void

math_equation_solve(MathEquation *equation)

{

g_timeout_add(100, math_equation_show_in_progress, equation);

}

static gpointer

math_equation_factorize_real(gpointer data)

{

return NULL;

}

void

math_equation_factorize(MathEquation *equation)

{

g_timeout_add(100, math_equation_show_in_progress, equation);

}

void

math_equation_delete(MathEquation *equation)

{

gtk_text_buffer_delete(GTK_TEXT_BUFFER(equation), &start, &end);

}

void

math_equation_backspace(MathEquation *equation)

{

}

}

void

math_equation_clear(MathEquation *equation)

{

clear_ans(equation, FALSE);

}

void

math_equation_shift(MathEquation *equation, gint count)

{

mp_clear(&z);

}

void

math_equation_toggle_bit(MathEquation *equation, guint bit)

{

mp_clear(&x);

}

static void

math_equation_set_property(GObject *object,

guint prop_id,

}

}

static void

math_equation_get_property(GObject *object,

guint prop_id,

}

}

static void

math_equation_constructed(GObject *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)

{

NULL);

}

static void

pre_insert_text_cb(MathEquation *equation,

GtkTextIter *location,

}

}

static gboolean

on_delete(MathEquation *equation)

{

return FALSE;

}

static void

pre_delete_range_cb(MathEquation *equation,

GtkTextIter *start,

}

}

static void

insert_text_cb(MathEquation *equation,

GtkTextIter *location,

g_object_notify(G_OBJECT(equation), "display");

}

static void

delete_range_cb(MathEquation *equation,

GtkTextIter *start,

g_object_notify(G_OBJECT(equation), "display");

}

static void

math_equation_init(MathEquation *equation)

{

#include "math-preferences.h"

#include "utility.h"

enum {

PROP_0,

PROP_EQUATION

#define GET_WIDGET(ui, name) \

GTK_WIDGET(gtk_builder_get_object(ui, name))

MathPreferencesDialog *

math_preferences_dialog_new(MathEquation *equation)

{

return g_object_new(math_preferences_get_type(), "equation", equation, NULL);

}

static void

preferences_response_cb(GtkWidget *widget, gint id)

{

gtk_widget_hide(widget);

}

static gboolean

preferences_dialog_delete_cb(GtkWidget *widget, GdkEvent *event)

{

return TRUE;

}

void number_format_combobox_changed_cb(GtkWidget *combo, MathPreferencesDialog *dialog);

G_MODULE_EXPORT

void

math_equation_set_number_format(dialog->priv->equation, value);

}

void angle_unit_combobox_changed_cb(GtkWidget *combo, MathPreferencesDialog *dialog);

G_MODULE_EXPORT

void

math_equation_set_angle_units(dialog->priv->equation, value);

}

void word_size_combobox_changed_cb(GtkWidget *combo, MathPreferencesDialog *dialog);

G_MODULE_EXPORT

void

math_equation_set_word_size(dialog->priv->equation, value);

}

void decimal_places_spin_change_value_cb(GtkWidget *spin, MathPreferencesDialog *dialog);

G_MODULE_EXPORT

void

math_equation_set_accuracy(dialog->priv->equation, value);

}

void thousands_separator_check_toggled_cb(GtkWidget *check, MathPreferencesDialog *dialog);

G_MODULE_EXPORT

void

math_equation_set_show_thousands_separators(dialog->priv->equation, value);

}

void trailing_zeroes_check_toggled_cb(GtkWidget *check, MathPreferencesDialog *dialog);

G_MODULE_EXPORT

void

math_equation_set_show_trailing_zeroes(dialog->priv->equation, value);

}

static void

set_combo_box_from_int(GtkWidget *combo, int value)

{

gtk_combo_box_set_active_iter(GTK_COMBO_BOX(combo), &iter);

}

static void

accuracy_cb(MathEquation *equation, GParamSpec *spec, MathPreferencesDialog *dialog)

{

g_settings_set_int(g_settings_var, "accuracy", math_equation_get_accuracy(equation));

}

static void

show_thousands_separators_cb(MathEquation *equation, GParamSpec *spec, MathPreferencesDialog *dialog)

{

g_settings_set_boolean(g_settings_var, "show-thousands", math_equation_get_show_thousands_separators(equation));

}

static void

show_trailing_zeroes_cb(MathEquation *equation, GParamSpec *spec, MathPreferencesDialog *dialog)

{

g_settings_set_boolean(g_settings_var, "show-zeroes", math_equation_get_show_trailing_zeroes(equation));

}

static void

number_format_cb(MathEquation *equation, GParamSpec *spec, MathPreferencesDialog *dialog)

{

g_settings_set_enum(g_settings_var, "number-format", math_equation_get_number_format(equation));

}

static void

word_size_cb(MathEquation *equation, GParamSpec *spec, MathPreferencesDialog *dialog)

{

g_settings_set_int(g_settings_var, "word-size", math_equation_get_word_size(equation));

}

static void

angle_unit_cb(MathEquation *equation, GParamSpec *spec, MathPreferencesDialog *dialog)

{

g_settings_set_enum(g_settings_var, "angle-units", math_equation_get_angle_units(equation));

}

static void

create_gui(MathPreferencesDialog *dialog)

{

angle_unit_cb(dialog->priv->equation, NULL, dialog);

}

static void

math_preferences_set_property(GObject *object,

guint prop_id,

}

}

static void

math_preferences_get_property(GObject *object,

guint prop_id,

}

}

static void

math_preferences_class_init(MathPreferencesDialogClass *klass)

{

G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));

}

static void

math_preferences_init(MathPreferencesDialog *dialog)

{

return g_object_new(math_variable_popup_get_type(), "equation", equation, NULL);

}

static void

variable_focus_out_event_cb(GtkWidget *widget, GdkEventFocus *event, MathVariablePopup *popup)

{

gtk_widget_destroy(widget);

}

static void

insert_variable_cb(GtkWidget *widget, MathVariablePopup *popup)

{

gtk_widget_destroy(gtk_widget_get_toplevel(widget));

}

static gboolean

variable_name_key_press_cb(GtkWidget *widget, GdkEventKey *event, MathVariablePopup *popup)

{

return FALSE;

}

static void

variable_name_changed_cb(GtkWidget *widget, MathVariablePopup *popup)

{

gtk_widget_set_sensitive(popup->priv->add_variable_button, text[0] != '\0');

}

static void

add_variable_cb(GtkWidget *widget, MathVariablePopup *popup)

{

mp_clear(&z);

}

static void

save_variable_cb(GtkWidget *widget, MathVariablePopup *popup)

{

mp_clear(&z);

}

static void

delete_variable_cb(GtkWidget *widget, MathVariablePopup *popup)

{

gtk_widget_destroy(gtk_widget_get_toplevel(widget));

}

static GtkWidget *

make_variable_entry(MathVariablePopup *popup, const gchar *name, const MPNumber *value, gboolean writable)

{

return hbox;

}

static void

math_variable_popup_set_property(GObject *object,

guint prop_id,

}

}

static void

math_variable_popup_get_property(GObject *object,

guint prop_id,

}

}

static void

math_variable_popup_class_init(MathVariablePopupClass *klass)

{

G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));

}

static void

math_variable_popup_init(MathVariablePopup *popup)

{

#include "math-variables.h"

#include "mp-serializer.h"

struct MathVariablesPrivate

{

gchar *file_name;

G_DEFINE_TYPE_WITH_PRIVATE (MathVariables, math_variables, G_TYPE_OBJECT);

MathVariables *

math_variables_new()

{

return g_object_new (math_variables_get_type(), NULL);

}

static void

registers_load(MathVariables *variables)

{

fclose(f);

}

static void

registers_save(MathVariables *variables)

{

fclose(f);

}

// FIXME: Sort

gchar **

math_variables_get_names(MathVariables *variables)

return names;

}

void

math_variables_set(MathVariables *variables, const char *name, const MPNumber *value)

{

registers_save(variables);

}

MPNumber *

math_variables_get(MathVariables *variables, const char *name)

{

return g_hash_table_lookup(variables->priv->registers, name);

}

void

math_variables_delete(MathVariables *variables, const char *name)

{

registers_save(variables);

}

static void

math_variables_class_init (MathVariablesClass *klass)

{

}

static void

math_variables_init(MathVariables *variables)

{

return window->priv->equation;

}

MathDisplay *

math_window_get_display(MathWindow *window)

{

return window->priv->display;

}

MathButtons *

math_window_get_buttons(MathWindow *window)

{

gtk_adjustment_set_value(adjustment, gtk_adjustment_get_upper(adjustment) - gtk_adjustment_get_page_size(adjustment));

}

static void

scroll_value_changed_cb(GtkAdjustment *adjustment, MathWindow *window)

{

gtk_widget_show(GTK_WIDGET(window->priv->buttons));

}

static void

math_window_set_property(GObject *object,

guint prop_id,

}

}

static void

math_window_get_property(GObject *object,

guint prop_id,

}

}

static void

math_window_class_init(MathWindowClass *klass)

{

G_TYPE_NONE, 0);

}

static void

math_window_init(MathWindow *window)

{

return 0;

}

static gchar *

to_hex_string(const MPNumber *x)

{

return result;

}

static void

mp_bitwise(const MPNumber *x, const MPNumber *y, int (*bitwise_operator)(int, int), MPNumber *z, int wordlen)

{

g_free(text2);

}

static int mp_bitwise_and(int v1, int v2) { return v1 & v2; }

static int mp_bitwise_or(int v1, int v2) { return v1 | v2; }

static int mp_bitwise_xor(int v1, int v2) { return v1 ^ v2; }

static int mp_bitwise_not(int v1, int dummy) { return v1 ^ 0xF; }

bool

mp_is_overflow (const MPNumber *x, int wordlen)

{

return is_overflow;

}

void

mp_and(const MPNumber *x, const MPNumber *y, MPNumber *z)

{

mp_bitwise(x, y, mp_bitwise_and, z, 0);

}

void

mp_or(const MPNumber *x, const MPNumber *y, MPNumber *z)

{

mp_bitwise(x, y, mp_bitwise_or, z, 0);

}

void

mp_xor(const MPNumber *x, const MPNumber *y, MPNumber *z)

{

mp_bitwise(x, y, mp_bitwise_xor, z, 0);

}

void

mp_not(const MPNumber *x, int wordlen, MPNumber *z)

{

mp_clear(&temp);

}

void

mp_shift(const MPNumber *x, int count, MPNumber *z)

{

mp_clear(&multiplier);

}

void

mp_ones_complement(const MPNumber *x, int wordlen, MPNumber *z)

{

mp_clear(&t);

}

void

mp_twos_complement(const MPNumber *x, int wordlen, MPNumber *z)

{

mpc_set(z->num, x->num, MPC_RNDNN);

}

void

mp_set_from_double(double dx, MPNumber *z)

{

mpc_set_d(z->num, dx, MPC_RNDNN);

}

void

mp_set_from_integer(long x, MPNumber *z)

{

mpc_set_si(z->num, x, MPC_RNDNN);

}

void

mp_set_from_unsigned_integer(ulong x, MPNumber *z)

{

mpc_set_ui(z->num, x, MPC_RNDNN);

}

void

mp_set_from_fraction(long numerator, long denominator, MPNumber *z)

{

mp_divide_integer(z, denominator, z);

}

void

mp_set_from_polar(const MPNumber *r, MPAngleUnit unit, const MPNumber *theta, MPNumber *z)

{

return mpfr_get_si(mpc_realref(x->num), MPFR_RNDN);

}

ulong

mp_to_unsigned_integer(const MPNumber *x)

{

return value;

}

static int

ends_with(const char *start, const char *end, const char *word)

{

return strncmp(end - word_len, word, word_len) == 0;

}

// FIXME: Doesn't handle errors well (e.g. trailing space)

static bool

set_from_sexagesimal(const char *str, int length, MPNumber *z)

return false;

}

bool

mp_set_from_string(const char *str, int default_base, MPNumber *z)

{

return 0;

}

static int

get_variable(ParserState *state, const char *name, MPNumber *z)

{

// i.e. numbers+letters = variable or function depending on following arg

// letters+numbers = numbers+letters+numbers = function

int

sub_atoi(const char *data)

{

return sign * value;

}

static int

function_is_defined(ParserState *state, const char *name)

{

return 0;

}

static int

get_function(ParserState *state, const char *name, const MPNumber *x, MPNumber *z)

{

return result;

}

static int

convert(ParserState *state, const MPNumber *x, const char *x_units, const char *z_units, MPNumber *z)

{

return 0;

}

MPErrorCode

mp_equation_parse(const char *expression, MPEquationOptions *options, MPNumber *result, char **error_token)

{

return PARSER_ERR_NONE;

}

const char *

mp_error_code_to_string(MPErrorCode error_code)

{

gint tsep_count; /* Number of digits between separator. */

};

G_DEFINE_TYPE_WITH_PRIVATE (MpSerializer, mp_serializer, G_TYPE_OBJECT);

MpSerializer *

return serializer;

}

static void

mp_to_string_real(MpSerializer *serializer, const MPNumber *x, int base, gboolean force_sign, int *n_digits, GString *string)

{

mp_clear(&temp);

}

static gchar *

mp_to_string(MpSerializer *serializer, const MPNumber *x, int *n_digits)

{

return result;

}

static int

mp_to_exponential_string_real(MpSerializer *serializer, const MPNumber *x, GString *string, gboolean eng_format, int *n_digits)

{

return exponent;

}

static void

append_exponent(GString *string, int exponent)

{

g_free (super_value);

}

static gchar *

mp_to_exponential_string(MpSerializer *serializer, const MPNumber *x, gboolean eng_format, int *n_digits)

{

return result;

}

gchar *

mp_serializer_to_string(MpSerializer *serializer, const MPNumber *x)

{

}

}

gboolean

mp_serializer_from_string(MpSerializer *serializer, const gchar *str, MPNumber *z)

{

return mp_set_from_string(str, serializer->priv->base, z);

}

void

mp_serializer_set_base(MpSerializer *serializer, gint base)

{

serializer->priv->base = base;

}

int

mp_serializer_get_base(MpSerializer *serializer)

{

return serializer->priv->base;

}

void

mp_serializer_set_radix(MpSerializer *serializer, gunichar radix)

{

serializer->priv->radix = radix;

}

gunichar

mp_serializer_get_radix(MpSerializer *serializer)

{

return serializer->priv->radix;

}

void

mp_serializer_set_thousands_separator(MpSerializer *serializer, gunichar separator)

{

serializer->priv->tsep = separator;

}

gunichar

mp_serializer_get_thousands_separator(MpSerializer *serializer)

{

return serializer->priv->tsep;

}

gint

mp_serializer_get_thousands_separator_count(MpSerializer *serializer)

{

return serializer->priv->tsep_count;

}

void

mp_serializer_set_show_thousands_separators(MpSerializer *serializer, gboolean visible)

{

serializer->priv->show_tsep = visible;

}

gboolean

mp_serializer_get_show_thousands_separators(MpSerializer *serializer)

{

return serializer->priv->show_tsep;

}

void

mp_serializer_set_show_trailing_zeroes(MpSerializer *serializer, gboolean visible)

{

serializer->priv->show_zeroes = visible;

}

gboolean

mp_serializer_get_show_trailing_zeroes(MpSerializer *serializer)

{

return serializer->priv->show_zeroes;

}

int

mp_serializer_get_leading_digits(MpSerializer *serializer)

{

return serializer->priv->leading_digits;

}

void

mp_serializer_set_leading_digits(MpSerializer *serializer, int leading_digits)

{

serializer->priv->leading_digits = leading_digits;

}

int

mp_serializer_get_trailing_digits(MpSerializer *serializer)

{

return serializer->priv->trailing_digits;

}

void

mp_serializer_set_trailing_digits(MpSerializer *serializer, int trailing_digits)

{

serializer->priv->trailing_digits = trailing_digits;

}

MpDisplayFormat

mp_serializer_get_number_format(MpSerializer *serializer)

{

return serializer->priv->format;

}

void

mp_serializer_set_number_format(MpSerializer *serializer, MpDisplayFormat format)

{

serializer->priv->format = format;

}

static void

mp_serializer_set_property(GObject *object,

guint prop_id,

}

}

static void

mp_serializer_get_property(GObject *object,

guint prop_id,

}

}

static void

mp_serializer_class_init(MpSerializerClass *klass)

{

G_PARAM_READWRITE));

}

static void

mp_serializer_init(MpSerializer *serializer)

{

mpfr_clear(scale);

}

void

mp_get_pi (MPNumber *z)

{

mpfr_set_zero(mpc_imagref(z->num), 0);

}

void

mp_sin(const MPNumber *x, MPAngleUnit unit, MPNumber *z)

{

mpc_sin(z->num, z->num, MPC_RNDNN);

}

void

mp_cos(const MPNumber *x, MPAngleUnit unit, MPNumber *z)

{

mpc_cos(z->num, z->num, MPC_RNDNN);

}

void

mp_tan(const MPNumber *x, MPAngleUnit unit, MPNumber *z)

{

mp_clear(&t1);

}

void

mp_asin(const MPNumber *x, MPAngleUnit unit, MPNumber *z)

{

mp_clear(&x_min);

}

void

mp_acos(const MPNumber *x, MPAngleUnit unit, MPNumber *z)

{

mp_clear(&x_min);

}

void

mp_atan(const MPNumber *x, MPAngleUnit unit, MPNumber *z)

{

mp_clear(&minus_i);

}

void

mp_sinh(const MPNumber *x, MPNumber *z)

{

mpc_sinh(z->num, x->num, MPC_RNDNN);

}

void

mp_cosh(const MPNumber *x, MPNumber *z)

{

mpc_cosh(z->num, x->num, MPC_RNDNN);

}

void

mp_tanh(const MPNumber *x, MPNumber *z)

{

mpc_tanh(z->num, x->num, MPC_RNDNN);

}

void

mp_asinh(const MPNumber *x, MPNumber *z)

{

mpc_asinh(z->num, x->num, MPC_RNDNN);

}

void

mp_acosh(const MPNumber *x, MPNumber *z)

{

mp_clear(&t);

}

void

mp_atanh(const MPNumber *x, MPNumber *z)

{

/** FACTORIZATION **/

/***********************************************************************/

/**

* mp_is_pprime uses the Miller-Rabin primality test to decide

* whether or not a number is probable prime.

static void pass(const char *format, ...) __attribute__((format(printf, 1, 2)));

static void fail(const char *format, ...) __attribute__((format(printf, 1, 2)));

static void pass(const char *format, ...)

{

/* va_list args;

fails++;

}

static const char *

error_code_to_string(MPErrorCode error)

{

return error_string;

}

static void

Test(char *expression, char *expected, int expected_error, int trailing_digits)

{

mp_clear(&result);

}

static int

do_convert(const MPNumber *x, const char *x_units, const char *z_units, MPNumber *z, void *data)

{

return unit_manager_convert_by_symbol(unit_manager_get_default(), x, x_units, z_units, z);

}

static void

test_conversions(void)

{

test("0 K in degC", "−273.15", 0);

}

static void try(const char* string, bool result, bool expected)

{

if ((result && !expected) || (!result && expected))

}

}

static void test_mp()

{

MPNumber zero = mp_new();

mp_clear(&minus_one);

}

static int

variable_is_defined(const char *name, void *data)

{

return strcmp (name, "x") == 0 || strcmp (name, "y") == 0;

}

static int

get_variable(const char *name, MPNumber *z, void *data)

{

return 0;

}

static void

set_variable(const char *name, const MPNumber *x, void *data)

{

//test("¬¬10₂", "10₂", 0);

}

int

main (void)

{

static void pass(const char *format, ...) __attribute__((format(printf, 1, 2)));

static void fail(const char *format, ...) __attribute__((format(printf, 1, 2)));

static void pass(const char *format, ...)

{

/* va_list args;

fails++;

}

static void

print_number(MPNumber *x)

{

mp_clear(&t);

}

static void

test_numbers(void)

{

test_string("16384.00006103515625");

}

static void

try(const char *string, bool result, bool expected)

{

pass("%s -> %s", string, result ? "true" : "false");

}

static void

test_mp(void)

{

mp_clear(&minus_one);

}

int

main (void)

{

G_DEFINE_TYPE_WITH_PRIVATE (UnitCategory, unit_category, G_TYPE_OBJECT);

UnitCategory *

unit_category_new(const gchar *name, const gchar *display_name)

{

return category;

}

const gchar *

unit_category_get_name(UnitCategory *category)

{

return category->priv->name;

}

const gchar *

unit_category_get_display_name(UnitCategory *category)

{

return category->priv->display_name;

}

void

unit_category_add_unit(UnitCategory *category, Unit *unit)

{

category->priv->units = g_list_append(category->priv->units, g_object_ref(unit));

}

Unit *

unit_category_get_unit_by_name(UnitCategory *category, const gchar *name)

{

return NULL;

}

Unit *

unit_category_get_unit_by_symbol(UnitCategory *category, const gchar *symbol)

{

return NULL;

}

const GList *

unit_category_get_units(UnitCategory *category)

{

return category->priv->units;

}

gboolean

unit_category_convert(const UnitCategory *category, const MPNumber *x, Unit *x_units, Unit *z_units, MPNumber *z)

{

return TRUE;

}

static void

unit_category_class_init(UnitCategoryClass *klass)

{

}

static void

unit_category_init(UnitCategory *category)

{

G_DEFINE_TYPE_WITH_PRIVATE (UnitManager, unit_manager, G_TYPE_OBJECT);

static UnitManager *default_unit_manager = NULL;

static gint

compare_currencies(gconstpointer a, gconstpointer b)

{

return strcmp(currency_get_display_name((Currency *)a), currency_get_display_name((Currency *)b));

}

UnitManager *

unit_manager_get_default(void)

{

return default_unit_manager;

}

UnitCategory *

unit_manager_add_category(UnitManager *manager, const gchar *name, const gchar *display_name)

{

return category;

}

const GList *

unit_manager_get_categories(UnitManager *manager)

{

return manager->priv->categories;

}

UnitCategory *

unit_manager_get_category(UnitManager *manager, const gchar *category)

{

return NULL;

}

Unit *

unit_manager_get_unit_by_name(UnitManager *manager, const gchar *name)

{

return NULL;

}

Unit *

unit_manager_get_unit_by_symbol(UnitManager *manager, const gchar *symbol)

{

return NULL;

}

gboolean

unit_manager_convert_by_symbol(UnitManager *manager, const MPNumber *x, const char *x_symbol, const char *z_symbol, MPNumber *z)

{

return FALSE;

}

static void

unit_manager_class_init(UnitManagerClass *klass)

{

}

static void

unit_manager_init(UnitManager *manager)

{

G_DEFINE_TYPE_WITH_PRIVATE (Unit, unit, G_TYPE_OBJECT);

Unit *

unit_new(const gchar *name,

const gchar *display_name,

return unit;

}

const gchar *

unit_get_name(Unit *unit)

{

return unit->priv->name;

}

const gchar *

unit_get_display_name(Unit *unit)

{

return unit->priv->display_name;

}

gboolean

unit_matches_symbol(Unit *unit, const gchar *symbol)

{

return FALSE;

}

const GList *

unit_get_symbols(Unit *unit)

{

return unit->priv->symbols;

}

static int

variable_is_defined(const char *name, void *data)

{

return TRUE;

}

static int

get_variable(const char *name, MPNumber *z, void *data)

{

return TRUE;

}

static gboolean

solve_function(const gchar *function, const MPNumber *x, MPNumber *z)

{

return TRUE;

}

gboolean

unit_convert_from(Unit *unit, const MPNumber *x, MPNumber *z)

{

}

}

gboolean

unit_convert_to(Unit *unit, const MPNumber *x, MPNumber *z)

{

}

}

gchar *

unit_format(Unit *unit, MPNumber *x)

{

return text;

}

static void

unit_class_init(UnitClass *klass)

{

}

static void

unit_init(Unit *unit)

{