static void
gnc_price_cell_modify_verify (BasicCell *_cell,
const char *change,
int change_len,
const char *newval,
int newval_len,
int *cursor_position,
int *start_selection,
int *end_selection)
{
PriceCell *cell = (PriceCell *) _cell;
struct lconv *lc = gnc_localeconv ();
const char *toks = "+-*/=()_";
gunichar decimal_point;
gunichar thousands_sep;
const char *c;
gunichar uc;
/* accept the newval string if user action was delete */
if (change == NULL)
{
gnc_basic_cell_set_value_internal (_cell, newval);
cell->need_to_parse = TRUE;
return;
}
if (cell->print_info.monetary)
decimal_point = g_utf8_get_char(lc->mon_decimal_point);
else
decimal_point = g_utf8_get_char(lc->decimal_point);
if (cell->print_info.monetary)
thousands_sep = g_utf8_get_char(lc->mon_thousands_sep);
else
thousands_sep = g_utf8_get_char(lc->thousands_sep);
c = change;
while (*c)
{
uc = g_utf8_get_char (c);
if (!g_unichar_isdigit (uc) &&
!g_unichar_isspace (uc) &&
!g_unichar_isalpha (uc) &&
(decimal_point != uc) &&
(thousands_sep != uc) &&
(g_utf8_strchr (toks, -1, uc) == NULL))
return;
c = g_utf8_next_char (c);
}
gnc_basic_cell_set_value_internal (_cell, newval);
cell->need_to_parse = TRUE;
}
/* Return the number of decimal places for this locale. */
int
gnc_locale_decimal_places (void)
{
static gboolean got_it = FALSE;
static int places;
struct lconv *lc;
if (got_it)
return places;
lc = gnc_localeconv();
places = lc->frac_digits;
/* frac_digits is already initialized by gnc_localeconv, hopefully
* to a reasonable default. */
got_it = TRUE;
return places;
}
const char *
gnc_locale_default_iso_currency_code (void)
{
static char *code = NULL;
struct lconv *lc;
if (code)
return code;
lc = gnc_localeconv ();
code = g_strdup (lc->int_curr_symbol);
/* The int_curr_symbol includes a space at the end! Note: you
* can't just change "USD " to "USD" in gnc_localeconv, because
* that is only used if int_curr_symbol was not defined in the
* current locale. If it was, it will have the space! */
g_strstrip (code);
return code;
}
static void
init_fi(FinCalcDialog *fcd)
{
struct lconv *lc;
if (fcd == NULL)
return;
lc = gnc_localeconv();
fcd->financial_info.npp = 12;
fcd->financial_info.ir = 8.5;
fcd->financial_info.pv = 15000.0;
fcd->financial_info.pmt = -400.0;
fcd->financial_info.CF = 12;
fcd->financial_info.PF = 12;
fcd->financial_info.bep = FALSE;
fcd->financial_info.disc = TRUE;
fcd->financial_info.prec = lc->frac_digits;
fi_calc_future_value(&fcd->financial_info);
}
static void
gnc_main_window_summary_refresh (GNCMainSummary * summary)
{
Account *root;
char asset_string[256];
char profit_string[256];
GNCCurrencyAcc *currency_accum;
GList *currency_list;
GList *current;
GNCSummarybarOptions options;
root = gnc_get_current_root_account ();
options.default_currency = xaccAccountGetCommodity(root);
if(options.default_currency == NULL)
{
options.default_currency = gnc_default_currency ();
}
options.euro = gnc_gconf_get_bool(GCONF_GENERAL, KEY_ENABLE_EURO, NULL);
options.grand_total =
gnc_gconf_get_bool(GCONF_SECTION, KEY_GRAND_TOTAL, NULL);
options.non_currency =
gnc_gconf_get_bool(GCONF_SECTION, KEY_NON_CURRENCY, NULL);
options.start_date = gnc_accounting_period_fiscal_start();
options.end_date = gnc_accounting_period_fiscal_end();
currency_list = NULL;
/* grand total should be first in the list */
if (options.grand_total)
{
gnc_ui_get_currency_accumulator (¤cy_list, options.default_currency,
TOTAL_GRAND_TOTAL);
}
/* Make sure there's at least one accumulator in the list. */
gnc_ui_get_currency_accumulator (¤cy_list, options.default_currency,
TOTAL_SINGLE);
gnc_ui_accounts_recurse(root, ¤cy_list, options);
{
GtkTreeIter iter;
char asset_amount_string[256], profit_amount_string[256];
struct lconv *lc;
lc = gnc_localeconv();
g_object_ref(summary->datamodel);
gtk_combo_box_set_model(GTK_COMBO_BOX(summary->totals_combo), NULL);
gtk_list_store_clear(summary->datamodel);
for (current = g_list_first(currency_list); current; current = g_list_next(current))
{
const char *mnemonic;
gchar *total_mode_label;
currency_accum = current->data;
if (gnc_commodity_equiv (currency_accum->currency, gnc_locale_default_currency ()))
mnemonic = lc->currency_symbol;
else
mnemonic = gnc_commodity_get_mnemonic (currency_accum->currency);
if (mnemonic == NULL)
mnemonic = "";
*asset_string = '\0';
xaccSPrintAmount(asset_amount_string,
currency_accum->assets,
gnc_commodity_print_info(currency_accum->currency, TRUE));
*profit_string = '\0';
xaccSPrintAmount(profit_amount_string,
currency_accum->profits,
gnc_commodity_print_info(currency_accum->currency, TRUE));
gtk_list_store_append(summary->datamodel, &iter);
total_mode_label = get_total_mode_label(mnemonic, currency_accum->total_mode);
gtk_list_store_set(summary->datamodel, &iter,
COLUMN_MNEMONIC_TYPE, total_mode_label,
COLUMN_ASSETS, _("Net Assets:"),
COLUMN_ASSETS_VALUE, asset_amount_string,
COLUMN_PROFITS, _("Profits:"),
COLUMN_PROFITS_VALUE, profit_amount_string,
-1);
g_free(total_mode_label);
}
gtk_combo_box_set_model(GTK_COMBO_BOX(summary->totals_combo),
GTK_TREE_MODEL(summary->datamodel));
g_object_unref(summary->datamodel);
gtk_combo_box_set_active(GTK_COMBO_BOX(summary->totals_combo), 0);
}
/* Free the list we created for this */
for (current = g_list_first(currency_list);
current;
current = g_list_next(current))
{
g_free(current->data);
}
g_list_free(currency_list);
}
static gboolean
gnc_price_cell_direct_update (BasicCell *bcell,
int *cursor_position,
int *start_selection,
int *end_selection,
void *gui_data)
{
PriceCell *cell = (PriceCell *) bcell;
GdkEventKey *event = gui_data;
struct lconv *lc;
gboolean is_return;
if (event->type != GDK_KEY_PRESS)
return FALSE;
lc = gnc_localeconv ();
is_return = FALSE;
#ifdef G_OS_WIN32
/* gdk never sends GDK_KP_Decimal on win32. See #486658 */
if (event->hardware_keycode == VK_DECIMAL)
event->keyval = GDK_KP_Decimal;
#endif
switch (event->keyval)
{
case GDK_KEY_Return:
if (!(event->state &
(GDK_CONTROL_MASK | GDK_MOD1_MASK | GDK_SHIFT_MASK)))
is_return = TRUE;
/* fall through */
case GDK_KEY_KP_Enter:
{
char *error_loc;
gnc_numeric amount;
gboolean parse_ok;
gboolean changed = FALSE;
if (!cell->need_to_parse)
return FALSE;
parse_ok = gnc_exp_parser_parse (cell->cell.value,
&amount, &error_loc);
if (parse_ok)
changed = gnc_price_cell_set_value (cell, amount);
else if (!cell->cell.value || cell->cell.value[0] == '\0')
changed = gnc_price_cell_set_value (cell,
gnc_numeric_zero ());
else
*cursor_position = error_loc - cell->cell.value;
/* If there is a problem with the parse, swallow
* the key so we stay put. */
if (!parse_ok)
return TRUE;
/* If nothing has changed, let the key cause a
* cursor activation no matter what. */
if (!changed)
return FALSE;
/* If it's not a plain return, stay put. This
* allows a 'calculator' style operation using
* keypad enter where you can keep entering more
* items to add, say. */
return !is_return;
}
case GDK_KEY_KP_Decimal:
break;
default:
return FALSE;
}
/* This point is only reached when the KP_Decimal key is pressed. */
gnc_basic_cell_insert_decimal(bcell,
cell->print_info.monetary
? lc->mon_decimal_point[0]
: lc->decimal_point[0],
cursor_position,
start_selection,
end_selection);
cell->need_to_parse = TRUE;
return TRUE;
}
static
gboolean
gnc_formula_cell_direct_update( BasicCell *bcell,
int *cursor_position,
int *start_selection,
int *end_selection,
void *gui_data )
{
FormulaCell *cell = (FormulaCell *)bcell;
GdkEventKey *event = gui_data;
struct lconv *lc;
gboolean is_return;
if (event->type != GDK_KEY_PRESS)
return FALSE;
lc = gnc_localeconv ();
is_return = FALSE;
/* FIXME!! This code is almost identical (except for GDK_KP_Enter
* handling) to pricecell-gnome.c:gnc_price_cell_direct_update. I write
* this after fixing a bug where one copy was kept up to date, and the
* other not. So, fix this.
*/
#ifdef G_OS_WIN32
/* gdk never sends GDK_KP_Decimal on win32. See #486658 */
if (event->hardware_keycode == VK_DECIMAL)
event->keyval = GDK_KP_Decimal;
#endif
switch (event->keyval)
{
case GDK_KEY_Return:
if (!(event->state &
(GDK_CONTROL_MASK | GDK_MOD1_MASK | GDK_SHIFT_MASK)))
is_return = TRUE;
/* FALL THROUGH */
case GDK_KEY_KP_Enter:
{
gnc_formula_cell_set_value( cell, cell->cell.value );
/* If it's not a plain return, stay put. This
* allows a 'calculator' style operation using
* keypad enter where you can keep entering more
* items to add, say. */
return !is_return;
}
case GDK_KEY_KP_Decimal:
break;
default:
return FALSE;
}
gnc_basic_cell_insert_decimal(bcell,
cell->print_info.monetary
? lc->mon_decimal_point[0]
: lc->decimal_point[0],
cursor_position,
start_selection,
end_selection);
return TRUE;
}
gboolean
gnc_exp_parser_parse_separate_vars (const char * expression,
gnc_numeric *value_p,
char **error_loc_p,
GHashTable *varHash )
{
parser_env_ptr pe;
var_store_ptr vars;
struct lconv *lc;
var_store result;
char * error_loc;
ParserNum *pnum;
if (expression == NULL)
return FALSE;
if (!parser_inited)
gnc_exp_parser_real_init ( (varHash == NULL) );
result.variable_name = NULL;
result.value = NULL;
result.next_var = NULL;
vars = make_predefined_variables ();
if ( varHash != NULL )
{
g_hash_table_foreach( varHash, make_predefined_vars_from_external_helper, &vars);
}
lc = gnc_localeconv ();
pe = init_parser (vars, lc->mon_decimal_point, lc->mon_thousands_sep,
trans_numeric, numeric_ops, negate_numeric, g_free,
func_op);
error_loc = parse_string (&result, expression, pe);
pnum = result.value;
if (error_loc == NULL)
{
if (gnc_numeric_check (pnum->value))
{
if (error_loc_p != NULL)
*error_loc_p = (char *) expression;
last_error = NUMERIC_ERROR;
}
else
{
if (pnum)
{
if (value_p)
*value_p = gnc_numeric_reduce (pnum->value);
if (!result.variable_name)
g_free (pnum);
}
if (error_loc_p != NULL)
*error_loc_p = NULL;
last_error = PARSER_NO_ERROR;
}
}
else
{
if (error_loc_p != NULL)
*error_loc_p = error_loc;
last_error = get_parse_error (pe);
}
if ( varHash != NULL )
{
var_store_ptr newVars;
gpointer maybeKey, maybeValue;
gnc_numeric *numericValue;
newVars = parser_get_vars( pe );
for ( ; newVars ; newVars = newVars->next_var )
{
pnum = newVars->value;
if ( g_hash_table_lookup_extended( varHash, newVars->variable_name,
&maybeKey, &maybeValue ) )
{
g_hash_table_remove( varHash, maybeKey );
g_free( maybeKey );
g_free( maybeValue );
}
numericValue = g_new0( gnc_numeric, 1 );
*numericValue = ((ParserNum*)newVars->value)->value;
// WTF?
// numericValue = NULL;
g_hash_table_insert( varHash,
g_strdup(newVars->variable_name),
numericValue );
}
}
else
{
update_variables (vars);
}
free_predefined_variables (vars);
exit_parser (pe);
return last_error == PARSER_NO_ERROR;
}
