g_file_copy_async(source, dest, G_FILE_COPY_OVERWRITE, G_PRIORITY_DEFAULT, NULL, NULL, NULL, callback, manager);

g_object_unref(source);

}

GError *error = NULL;

int i;

gboolean result, in_data = FALSE;

{

const gchar *name, *symbol;

{

{"Algerian dinar", "DZD"},

{"Australian dollar", "AUD"},

gchar *line, **tokens;

line = g_strchug(lines[i]);

/* Start after first blank line, stop on next */

if (line[0] == '\0') {

if (!in_data) {

if (!document)

g_warning("Couldn't parse ECB rate file %s", filename);

g_free (filename);

return;

xpath_ctx = xmlXPathNewContext(document);

loaded_rates = TRUE;

g_signal_emit(manager, signals[UPDATED], 0);

return TRUE;

}

#include "currency.h"

#include "mp.h"

G_BEGIN_DECLS

#define CURRENCY_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), currency_manager_get_type(), CurrencyManager))

MPEquationOptions options;

MPNumber z;

gchar *result_str = NULL;

memset(&options, 0, sizeof(options));

options.base = 10;

options.wordlen = 32;

options.angle_units = MP_DEGREES;

ret = mp_equation_parse(equation, &options, &z, NULL);

if (ret == PARSER_ERR_MP)

fprintf(stderr, "Error %s\n", mp_get_error());

fprintf(stderr, "Error %d\n", ret);

else {

result_str = mp_serializer_to_string(result_serializer, &z);

static void

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

{

object = gtk_builder_get_object(ui, object_name);

if (object)

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

if (!buttons->priv->bit_panel)

return;

enabled = math_equation_get_number(buttons->priv->equation, &x);

if (enabled) {

gtk_widget_set_sensitive(buttons->priv->bit_panel, enabled);

gtk_widget_set_sensitive(buttons->priv->base_label, enabled);

if (!enabled)

return;

gtk_label_set_text(GTK_LABEL(buttons->priv->bit_labels[i]), label);

}

label = g_string_new("");

if (base != 8) {

if (label->len != 0)

GtkTreeModel *model;

GtkTreeIter iter;

gboolean valid;

if (buttons->priv->mode != PROGRAMMING)

return;

panel = &buttons->priv->prog_panel;

break;

}

if (*panel)

goto out;

if (button_data[i].tooltip)

gtk_widget_set_tooltip_text(button, _(button_data[i].tooltip));

atk_object_set_name(gtk_widget_get_accessible(button), button_data[i].widget_name);

}

buffer[len] = '\0';

gtk_button_set_label(GTK_BUTTON(widget), buffer);

}

widget = GET_WIDGET(builder, "calc_superscript_button");

if (widget) {

buttons->priv->superscript_toggles = g_list_append(buttons->priv->superscript_toggles, widget);

gtk_builder_connect_signals(builder, buttons);

display_changed_cb(buttons->priv->equation, NULL, buttons);

out:

return *panel;

}

}

else {

math_equation_set_source_units(buttons->priv->equation, unit_get_name(from_unit));

}

g_object_unref(from_unit);

if (!buttons->priv->converter) {

buttons->priv->converter = math_converter_new(buttons->priv->equation);

g_signal_connect(buttons->priv->converter, "changed", G_CALLBACK(converter_changed_cb), buttons);

}

panel = load_mode(buttons, buttons->priv->mode);

math_buttons_set_mode(MathButtons *buttons, ButtonMode mode)

{

g_return_if_fail(buttons != NULL);

if (buttons->priv->mode == mode)

return;

buttons->priv->mode = mode;

if (mode == PROGRAMMING)

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

else

void

subtract_cb(GtkWidget *widget, MathButtons *buttons)

{

}

popup = math_variable_popup_new(buttons->priv->equation);

gtk_window_set_transient_for(GTK_WINDOW(popup), GTK_WINDOW(gtk_widget_get_toplevel(widget)));

gdk_window_get_root_coords(gtk_widget_get_window(widget), allocation.x, allocation.y, &x, &y);

gtk_window_move(GTK_WINDOW(popup), x, y);

gtk_widget_show(GTK_WIDGET(popup));

}

}

}

if (!buttons->priv->function_menu) {

gint i;

GtkWidget *menu;

{

gchar *name, *function;

{

{ /* Tooltip for the integer component button */

N_("Integer Component"), "int " },

for (i = 0; functions[i].name != NULL; i++) {

GtkWidget *item;

item = gtk_menu_item_new_with_label(_(functions[i].name));

g_object_set_data(G_OBJECT(item), "function", g_strdup(functions[i].function));

gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);

}

}

}

static void

if (!buttons->priv->const_menu) {

gint i;

GtkWidget *menu;

{

gchar *name, *constant, *tooltip;

{

{ /* Tooltip for the c₀ component button */

N_("Velocity of Light"), "c₀", N_("299,792,458 m/s") },

for (i = 0; constants[i].name != NULL; i++) {

GtkWidget *item;

item = gtk_menu_item_new_with_label(_(constants[i].name));

gtk_widget_set_tooltip_text(item, _(constants[i].tooltip));

g_object_set_data(G_OBJECT(item), "const", g_strdup(constants[i].constant));

}

}

}

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

text = gtk_entry_get_text(GTK_ENTRY(buttons->priv->character_code_entry));

MPNumber x;

int i = 0;

{

GList *i;

NumberMode mode;

mode = math_equation_get_number_mode(equation);

for (i = buttons->priv->superscript_toggles; i; i = i->next) {

UnitCategory *category = iter->data;

GtkTreeIter parent;

const GList *unit_iter;

gtk_tree_store_append(from_model, &parent, NULL);

gtk_tree_store_set(from_model, &parent, 0, unit_category_get_display_name(category), 1, category, -1);

Unit *u;

gtk_tree_model_get(model, iter, 2, &u, -1);

if (!u)

return FALSE;

g_object_unref(u);

if (u == unit)

return TRUE;

return FALSE;

}

GtkTreeIter child_iter;

model = gtk_combo_box_get_model(combo);

if (iter && iter_is_unit(model, iter, unit)) {

gtk_combo_box_set_active_iter(combo, iter);

return TRUE;

if (!gtk_tree_model_iter_children(model, &child_iter, iter))

return FALSE;

do {

if (set_active_unit(combo, &child_iter, unit))

return TRUE;

} while (gtk_tree_model_iter_next(model, &child_iter));

return FALSE;

}

/* Select the first possible unit */

gtk_combo_box_set_active(GTK_COMBO_BOX(converter->priv->to_combo), 0);

g_object_unref(unit);

}

}

math_display_init(MathDisplay *display)

{

display->priv = math_display_get_instance_private (display);

PROP_SOURCE_CURRENCY,

PROP_TARGET_CURRENCY,

PROP_SOURCE_UNITS,

PROP_SERIALIZER

};

GList *undo_stack; /* History of expression mode states */

GList *redo_stack;

gboolean in_undo_operation;

gboolean in_reformat;

gboolean in_delete;

get_ans_offsets(MathEquation *equation, gint *start, gint *end)

{

GtkTextIter iter;

if (!equation->priv->ans_start) {

*start = *end = -1;

return;

offset--;

}

else

}

else {

in_number = in_radix = FALSE;

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;

}

equation->priv->redo_stack = NULL;

state = get_current_state(equation);

}

apply_state(MathEquation *equation, MathEquationState *state)

{

GtkTextIter cursor;

/* Disable undo detection */

equation->priv->in_undo_operation = TRUE;

g_free(equation->priv->state.status);

equation->priv->state.status = g_strdup(status);

}

{

char *text;

gboolean result;

g_return_val_if_fail(equation != NULL, FALSE);

text = math_equation_get_equation(equation);

next_is_digit = g_unichar_isdigit(g_utf8_get_char(g_utf8_next_char(read_iter)));

/* Replace ans text with variable */

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;

math_equation_store(MathEquation *equation, const gchar *name)

{

MPNumber t;

g_return_if_fail(equation != NULL);

g_return_if_fail(name != NULL);

for (c = lower_name; *c; c++)

*c = tolower(*c);

strcmp(lower_name, "ans") == 0) {

g_free(lower_name);

return 1;

g_value_set_string(value, self->priv->state.status);

break;

case PROP_DISPLAY:

g_value_set_string(value, text);

g_free(text);

break;

g_param_spec_int("base",

"base",

"Default number base (derived from number-format)",

G_PARAM_READWRITE));

g_object_class_install_property(object_class,

PROP_WORD_SIZE,

{

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)

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)

{

return FALSE;

}

GtkTextIter *start,

GtkTextIter *end,

gpointer user_data)

if (equation->priv->in_reformat)

return;

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

equation->priv = math_equation_get_instance_private (equation);

g_signal_connect(equation, "insert-text", G_CALLBACK(pre_insert_text_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);

MathPreferencesDialog *

math_preferences_dialog_new(MathEquation *equation)

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

}

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

}

const gchar *text = gtk_entry_get_text(GTK_ENTRY(popup->priv->variable_name_entry));

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

}

static void

add_variable_cb(GtkWidget *widget, MathVariablePopup *popup)

MPNumber z;

name = g_object_get_data(G_OBJECT(widget), "variable_name");

math_variables_set(math_equation_get_variables(popup->priv->equation), name, &z);

else if (math_equation_is_result(popup->priv->equation))

math_variables_set(math_equation_get_variables(popup->priv->equation), name, math_equation_get_answer(popup->priv->equation));

{

const gchar *name;

math_variables_delete(math_equation_get_variables(popup->priv->equation), name);

gtk_widget_destroy(gtk_widget_get_toplevel(widget));

{

FILE *f;

char line[1024];

f = fopen(variables->priv->file_name, "r");

if (!f)

return;

g_hash_table_remove_all(variables->priv->registers);

while (fgets(line, 1024, f) != NULL)

{

char *name, *value;

MPNumber *t;

value = strchr(line, '=');

if (!value)

continue;

*value = '\0';

value = value + 1;

name = g_strstrip(line);

value = g_strstrip(value);

f = fopen(variables->priv->file_name, "w");

if (!f)

return;

g_hash_table_iter_init(&iter, variables->priv->registers);

while (g_hash_table_iter_next(&iter, &key, &val))

{

gpointer key;

gint i = 0;

gchar **names;

g_return_val_if_fail(variables != NULL, NULL);

names = g_malloc0(sizeof(gchar *) * (g_hash_table_size(variables->priv->registers) + 1));

vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 6);

gtk_container_set_border_width(GTK_CONTAINER(vbox), 6);

gtk_widget_show(vbox);

scrolled_window = gtk_scrolled_window_new(NULL, NULL);

{

int i;

int64_t z = 0, v;

/* |x| <= 1 */

if (x->sign == 0 || x->exponent <= 0)

return 0;

t = z;

z = z * MP_BASE + x->fraction[i];

/* Check for overflow */

if (z <= t)

return 0;

{

int i;

uint64_t z = 0, v;

/* x <= 1 */

if (x->sign <= 0 || x->exponent <= 0)

return 0;

t = z;

z = z * MP_BASE + x->fraction[i];

/* Check for overflow */

if (z <= t)

return 0;

/*

* Copyright (C) 2004-2008 Sami Pietila

* 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 of the License, or (at your option) any later

else if (strcmp(name, "mₚ") == 0)

mp_set_from_string("0.000000000000000000000000001672621898", 10, z); /* proton mass */

else if (strcmp(name, "Nₐ") == 0)

else if (state->options->get_variable)

result = state->options->get_variable(name, z, state->options->callback_data);

else

/*

* Copyright (C) 2004-2008 Sami Pietila

* 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 of the License, or (at your option) any later

/* Data to pass to callbacks */

void *callback_data;

/* Function to check if a variable is defined */

int (*variable_is_defined)(const char *name, void *data);

/*

* Copyright (C) 2010 Robin Sonefors

* 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 of the License, or (at your option) any later

fixed = mp_cast_to_string(serializer, &mantissa, n_digits);

g_string_append(string, fixed);

g_free(fixed);

return exponent;

}

{

const gchar *super_digits[] = {"⁰", "¹", "²", "³", "⁴", "⁵", "⁶", "⁷", "⁸", "⁹"};

gchar *super_value, *c;

if (exponent == 0)

return;

g_param_spec_int("base",

"base",

"Default number base",

G_PARAM_READWRITE));

}

/*

* Copyright (C) 2010 Robin Sonefors

* 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 of the License, or (at your option) any later

/*

* 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 of the License, or (at your option) any later

break;

q *= 2;

/* t = t / (√(t² + 1) + 1) */

mp_multiply(&t2, &t2, z);

mp_add_integer(z, 1, z);

z->sign = x->im_sign;

z->exponent = x->im_exponent;

memcpy(z->fraction, x->im_fraction, sizeof(int) * MP_SIZE);

z->im_sign = 0;

z->im_exponent = 0;

memset(z->im_fraction, 0, sizeof(int) * MP_SIZE);

z->sign = y_sign;

return;

}

else if (mp_is_zero(y)) {

mp_set_from_mp(x, z);

return;

else if (mp_is_negative(x))

mp_set_from_integer(-1, z);

else

}

void

mp_is_integer(const MPNumber *x)

{

MPNumber t1, t2, t3;

if (mp_is_complex(x))

return false;

mp_logarithm(int64_t n, const MPNumber *x, MPNumber *z)

{

MPNumber t1, t2;

/* log(0) undefined */

if (mp_is_zero(x)) {

/* Translators: Error displayed when attempting to take logarithm of zero */

int c, i, xi;

MPNumber r;

if (x->sign == 0 || y->sign == 0) {

mp_set_from_integer(0, z);

return;

/* Clear complex part */

z->im_sign = 0;

z->im_exponent = 0;

/* NORMALIZE AND ROUND RESULT */

// FIXME: Use stack variable because of mp_normalize brokeness

mp_imaginary_component(x, &im_x);

mp_real_component(y, &real_y);

mp_imaginary_component(y, &im_y);

mp_multiply_real(&real_x, &real_y, &t1);

mp_multiply_real(&im_x, &im_y, &t2);

mp_subtract(&t1, &t2, &real_z);

mp_multiply_real(&real_x, &im_y, &t1);

mp_multiply_real(&im_x, &real_y, &t2);

mp_add(&t1, &t2, &im_z);

z->im_sign = 0;

z->im_exponent = 0;

mp_normalize(z);

}

return;

}*/

if (mp_is_zero(x)) {

mp_set_from_integer(0, z);

if (y->sign < 0)

void

mp_reciprocal(const MPNumber *x, MPNumber *z)

if (mp_is_complex(x)) {

MPNumber t1, t2;

MPNumber real_x, im_x;

mp_set_from_integer(0, z);

return;

}

/* x^1 = x */

if (n == 1) {

mp_set_from_mp(x, z);

/*

* 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 of the License, or (at your option) any later

/*

* 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 of the License, or (at your option) any later

options.wordlen = 32;

options.angle_units = MP_DEGREES;

options.convert = do_convert;

/* Angle units */

//test("π radians in degrees", "180", 0);

test("100 gradians in degrees", "90", 0);

/* Length */

test("1m in mm", "1000", 0);

test("1 inch in cm", "2.54", 0);

/* Area */

test("1m² in mm²", "1000000", 0);

/* Volume */

/* Weight */

test("1 kg in pounds", "2.204622622", 0);

/* Duration */

test("1 minute in seconds", "60", 0);

test("1s in ms", "1000", 0);

mp_set_from_integer (3, z);

return 1;

}

}

memset(&options, 0, sizeof(options));

options.wordlen = 32;

options.angle_units = MP_DEGREES;

options.get_variable = get_variable;

options.set_variable = set_variable;

test("١٢٣٤٥٦٧٨٩٠", "1234567890", 0);

test("۱۲۳۴۵۶۷۸۹۰", "1234567890", 0);

//test("2A", "2000000000000000", 0);

test("2T", "2000000000000", 0);

test("2G", "2000000000", 0);

test("2y", "6", 0);

test("y2", "", PARSER_ERR_INVALID);

test("y 2", "", PARSER_ERR_INVALID);

test("z2", "", PARSER_ERR_UNKNOWN_VARIABLE);

test("z 2", "", PARSER_ERR_UNKNOWN_VARIABLE);

test("z(2)", "", PARSER_ERR_UNKNOWN_VARIABLE);

test("8 mod 7", "1", 0);

test("−1 mod 7", "6", 0);

test("sgn 3", "1", 0);

test("sgn −3", "−1", 0);

test("⌊3⌋", "3", 0);

test("i", "i", 0);

test("−i", "−i", 0);

test("2i", "2i", 0);

test("i+1", "1+i", 0);

test("i−1", "−1+i", 0);

test("i×i", "−1", 0);

test("i÷i", "1", 0);

test("1÷i", "−i", 0);

test("|i|", "1", 0);

test("|3+4i|", "5", 0);

test("arg 1", "0", 0);

test("arg (1+i)", "45", 0);

test("arg i", "90", 0);

test("1 and 1", "1", 0);

test("3 and 5", "1", 0);

test("1 or 0", "1", 0);

test("1 or 1", "1", 0);

test("3 or 5", "7", 0);

/*

* 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 of the License, or (at your option) any later

test_mp()

{

MPNumber zero, one, minus_one;

mp_set_from_integer(0, &zero);

mp_set_from_integer(1, &one);

mp_set_from_integer(-1, &minus_one);

try("mp_is_zero(-1)", mp_is_zero(&minus_one), false);

try("mp_is_zero(0)", mp_is_zero(&zero), true);

try("mp_is_zero(1)", mp_is_zero(&one), false);

try("mp_is_equal(1, 0)", mp_is_equal(&one, &zero), false);

try("mp_is_equal(1, 1)", mp_is_equal(&one, &one), true);

try("mp_is_greater_than(0, 0)", mp_is_greater_than (&zero, &zero), false);

try("mp_is_greater_than(0, 1)", mp_is_greater_than (&zero, &one), false);

try("mp_is_greater_than(1, 0)", mp_is_greater_than (&one, &zero), true);

try("mp_is_greater_than(1, 1)", mp_is_greater_than (&one, &one), false);

try("mp_is_greater_than(-1, 0)", mp_is_greater_than (&minus_one, &zero), false);

try("mp_is_greater_than(-1, 1)", mp_is_greater_than (&minus_one, &one), false);

try("mp_is_greater_equal(0, 0)", mp_is_greater_equal (&zero, &zero), true);

try("mp_is_greater_equal(0, 1)", mp_is_greater_equal (&zero, &one), false);

try("mp_is_greater_equal(1, -1)", mp_is_greater_equal (&one, &minus_one), true);

try("mp_is_greater_equal(-1, 0)", mp_is_greater_equal (&minus_one, &zero), false);

try("mp_is_greater_equal(-1, 1)", mp_is_greater_equal (&minus_one, &one), false);

try("mp_is_less_than(0, 0)", mp_is_less_than (&zero, &zero), false);

try("mp_is_less_than(0, 1)", mp_is_less_than (&zero, &one), true);

try("mp_is_less_than(1, 0)", mp_is_less_than (&one, &zero), false);

try("mp_is_less_than(1, 1)", mp_is_less_than (&one, &one), false);

try("mp_is_less_than(-1, 0)", mp_is_less_than (&minus_one, &zero), true);

try("mp_is_less_than(-1, 1)", mp_is_less_than (&minus_one, &one), true);

try("mp_is_less_equal(0, 0)", mp_is_less_equal (&zero, &zero), true);

try("mp_is_less_equal(0, 1)", mp_is_less_equal (&zero, &one), true);

try("mp_is_less_equal(1, 0)", mp_is_less_equal (&one, &zero), false);

try("mp_is_less_equal(1, 1)", mp_is_less_equal (&one, &one), true);

try("mp_is_less_equal(-1, 0)", mp_is_less_equal (&minus_one, &zero), true);

try("mp_is_less_equal(-1, 1)", mp_is_less_equal (&minus_one, &one), true);

}

/*

* 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 of the License, or (at your option) any later

if (strcmp(unit_get_name(unit), name) == 0)

return unit;

}

return NULL;

}

/*

* 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 of the License, or (at your option) any later

/*

* 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 of the License, or (at your option) any later

unit_manager_get_category(UnitManager *manager, const gchar *category)

{

GList *iter;

g_return_val_if_fail(manager != NULL, NULL);

g_return_val_if_fail(category != NULL, NULL);

return u;

}

}

Unit *u;

g_return_val_if_fail(manager != NULL, NULL);

for (iter = manager->priv->categories; iter; iter = iter->next) {

UnitCategory *c = iter->data;

return u;

}

}

if (x_units && z_units && unit_category_convert(c, x, x_units, z_units, z))

return TRUE;

}

return FALSE;

}

/*

* 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 of the License, or (at your option) any later

/*

* 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 of the License, or (at your option) any later

/*

* 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 of the License, or (at your option) any later