/* Is current split a security account */
static gboolean
gtu_sr_use_security (GncTreeViewSplitReg *view)
{
RowDepth depth;
Account *account = NULL;
Split *split;
split = gnc_tree_view_split_reg_get_current_split (view);
depth = gnc_tree_view_reg_get_selected_row_depth (view);
if (!split)
return TRUE;
if (depth != SPLIT3)
return TRUE;
if (!account)
account = xaccSplitGetAccount (split);
if (!account)
return TRUE;
if (xaccTransUseTradingAccounts (xaccSplitGetParent (split)))
{
if (!gnc_commodity_is_iso (xaccAccountGetCommodity (account)))
return TRUE;
}
return xaccAccountIsPriced (account);
}
gnc_numeric
gnc_convert_from_euro(const gnc_commodity * currency, gnc_numeric value)
{
gnc_euro_rate_struct * result;
if (currency == NULL)
return gnc_numeric_zero ();
if (!gnc_commodity_is_iso(currency))
return gnc_numeric_zero ();
result = bsearch(currency,
gnc_euro_rates,
sizeof(gnc_euro_rates) / sizeof(gnc_euro_rate_struct),
sizeof(gnc_euro_rate_struct),
gnc_euro_rate_compare);
if (result == NULL)
return gnc_numeric_zero ();
{
gnc_numeric rate;
rate = double_to_gnc_numeric (result->rate, 100000, GNC_HOW_RND_ROUND_HALF_UP);
/* EC Regulation 1103/97 states we should use "Round half away from zero"
* See http://europa.eu/legislation_summaries/economic_and_monetary_affairs/institutional_and_economic_framework/l25025_en.htm */
return gnc_numeric_mul (value, rate, gnc_commodity_get_fraction (currency),
GNC_HOW_RND_ROUND_HALF_UP);
}
}
xmlNodePtr
gnc_commodity_dom_tree_create(const gnc_commodity *com)
{
gnc_quote_source *source;
const char *string;
xmlNodePtr ret;
gboolean currency = gnc_commodity_is_iso(com);
xmlNodePtr slotsnode =
qof_instance_slots_to_dom_tree(cmdty_slots, QOF_INSTANCE(com));
if (currency && !gnc_commodity_get_quote_flag(com) && !slotsnode)
return NULL;
ret = xmlNewNode(NULL, BAD_CAST gnc_commodity_string);
xmlSetProp(ret, BAD_CAST "version", BAD_CAST commodity_version_string);
xmlAddChild(ret, text_to_dom_tree(cmdty_namespace,
gnc_commodity_get_namespace_compat(com)));
xmlAddChild(ret, text_to_dom_tree(cmdty_id,
gnc_commodity_get_mnemonic(com)));
if (!currency)
{
if (gnc_commodity_get_fullname(com))
{
xmlAddChild(ret, text_to_dom_tree(cmdty_name,
gnc_commodity_get_fullname(com)));
}
if (gnc_commodity_get_cusip(com) &&
strlen(gnc_commodity_get_cusip(com)) > 0)
{
xmlAddChild(ret, text_to_dom_tree(
cmdty_xcode,
gnc_commodity_get_cusip(com)));
}
xmlAddChild(ret, int_to_dom_tree(cmdty_fraction,
gnc_commodity_get_fraction(com)));
}
if (gnc_commodity_get_quote_flag(com))
{
xmlNewChild(ret, NULL, BAD_CAST cmdty_get_quotes, NULL);
source = gnc_commodity_get_quote_source(com);
if (source)
xmlAddChild(ret, text_to_dom_tree(cmdty_quote_source,
gnc_quote_source_get_internal_name(source)));
string = gnc_commodity_get_quote_tz(com);
if (string)
xmlAddChild(ret, text_to_dom_tree(cmdty_quote_tz, string));
}
if (slotsnode)
xmlAddChild(ret, slotsnode);
return ret;
}
static gboolean
check_quote_source (gnc_commodity *com, gpointer data)
{
gboolean *commodity_has_quote_src = (gboolean *)data;
if (com && !gnc_commodity_is_iso(com))
*commodity_has_quote_src |= gnc_commodity_get_quote_flag(com);
return TRUE;
}
static gboolean
gnc_commodities_dialog_filter_cm_func (gnc_commodity *commodity,
gpointer data)
{
CommoditiesDialog *cd = data;
if (cd->show_currencies)
return TRUE;
return !gnc_commodity_is_iso(commodity);
}
static void
gnc_commodities_dialog_selection_changed (GtkTreeSelection *selection,
CommoditiesDialog *cd)
{
gboolean remove_ok;
gnc_commodity *commodity;
commodity = gnc_tree_view_commodity_get_selected_commodity (cd->commodity_tree);
remove_ok = commodity && !gnc_commodity_is_iso(commodity);
gtk_widget_set_sensitive (cd->edit_button, commodity != NULL);
gtk_widget_set_sensitive (cd->remove_button, remove_ok);
}
gboolean
gnc_is_euro_currency(const gnc_commodity * currency)
{
gnc_euro_rate_struct *result;
if (currency == NULL)
return FALSE;
if (!gnc_commodity_is_iso(currency))
return FALSE;
result = bsearch(currency,
gnc_euro_rates,
sizeof(gnc_euro_rates) / sizeof(gnc_euro_rate_struct),
sizeof(gnc_euro_rate_struct),
gnc_euro_rate_compare);
if (result == NULL)
return FALSE;
return TRUE;
}
gnc_numeric
gnc_euro_currency_get_rate (const gnc_commodity *currency)
{
gnc_euro_rate_struct * result;
if (currency == NULL)
return gnc_numeric_zero ();
if (!gnc_commodity_is_iso(currency))
return gnc_numeric_zero ();
result = bsearch(currency,
gnc_euro_rates,
sizeof(gnc_euro_rates) / sizeof(gnc_euro_rate_struct),
sizeof(gnc_euro_rate_struct),
gnc_euro_rate_compare);
if (result == NULL)
return gnc_numeric_zero ();
return double_to_gnc_numeric (result->rate, GNC_DENOM_AUTO,
GNC_HOW_DENOM_SIGFIGS(6) | GNC_HOW_RND_ROUND_HALF_UP);
}
static void
gnc_split_register_save_amount_values (SRSaveData *sd, SplitRegister *reg)
{
Account *acc;
gnc_numeric new_amount, convrate, amtconv, value;
gnc_commodity *curr, *reg_com, *xfer_com;
Account *xfer_acc;
new_amount = gnc_split_register_debcred_cell_value (reg);
acc = gnc_split_register_get_default_account (reg);
xfer_acc = xaccSplitGetAccount (sd->split);
xfer_com = xaccAccountGetCommodity (xfer_acc);
reg_com = xaccAccountGetCommodity (acc);
curr = xaccTransGetCurrency (sd->trans);
/* First, compute the conversion rate to convert the value to the
* amount.
*/
amtconv = convrate = gnc_split_register_get_rate_cell (reg, RATE_CELL);
if (acc && gnc_split_register_needs_conv_rate (reg, sd->trans, acc))
{
/* If we are in an expanded register and the xfer_acc->comm !=
* reg_acc->comm then we need to compute the convrate here.
* Otherwise, we _can_ use the rate_cell!
*/
if (sd->reg_expanded && ! gnc_commodity_equal (reg_com, xfer_com))
amtconv = xaccTransGetAccountConvRate(sd->trans, acc);
}
if (xaccTransUseTradingAccounts (sd->trans))
{
/* Using currency accounts, the amount is probably really the
amount and not the value. */
gboolean is_amount;
if (reg->type == STOCK_REGISTER ||
reg->type == CURRENCY_REGISTER ||
reg->type == PORTFOLIO_LEDGER)
{
if (xaccAccountIsPriced(xfer_acc) ||
!gnc_commodity_is_iso(xaccAccountGetCommodity(xfer_acc)))
is_amount = FALSE;
else
is_amount = TRUE;
}
else
{
is_amount = TRUE;
}
if (is_amount)
{
xaccSplitSetAmount(sd->split, new_amount);
if (gnc_split_register_split_needs_amount (reg, sd->split))
{
value = gnc_numeric_div(new_amount, amtconv,
gnc_commodity_get_fraction(curr),
GNC_HOW_RND_ROUND_HALF_UP);
xaccSplitSetValue(sd->split, value);
}
else
xaccSplitSetValue(sd->split, new_amount);
}
else
{
xaccSplitSetValue(sd->split, new_amount);
}
return;
}
/* How to interpret new_amount depends on our view of this
* transaction. If we're sitting in an account with the same
* commodity as the transaction, then we can set the Value and then
* compute the amount. Otherwise we are setting the "converted
* value". This means we need to convert new_amount to the actual
* 'value' by dividing by the convrate in order to set the value.
*/
/* Now compute/set the split value. Amount is in the register
* currency but we need to convert to the txn currency.
*/
if (gnc_split_register_needs_conv_rate (reg, sd->trans, acc))
{
/* convert the amount to the Value ... */
value = gnc_numeric_div (new_amount, amtconv,
gnc_commodity_get_fraction (curr),
GNC_HOW_RND_ROUND_HALF_UP);
xaccSplitSetValue (sd->split, value);
}
else
xaccSplitSetValue (sd->split, new_amount);
/* Now re-compute the Amount from the Value. We may need to convert
* from the Value back to the amount here using the convrate from
* earlier.
*/
value = xaccSplitGetValue (sd->split);
if (gnc_split_register_split_needs_amount (reg, sd->split))
{
acc = xaccSplitGetAccount (sd->split);
new_amount = gnc_numeric_mul (value, convrate,
xaccAccountGetCommoditySCU (acc),
GNC_HOW_RND_ROUND_HALF_UP);
xaccSplitSetAmount (sd->split, new_amount);
}
}
void
gnc_tree_util_split_reg_save_amount_values (GncTreeViewSplitReg *view, Transaction *trans, Split *split, gnc_numeric input)
{
GncTreeModelSplitReg *model;
Account *acc;
gnc_numeric new_amount, convrate, amtconv, value;
gnc_commodity *curr, *reg_com, *xfer_com;
Account *xfer_acc;
ENTER("View is %p, trans is %p, split is %p, input is %s", view, trans, split, gnc_numeric_to_string (input));
model = gnc_tree_view_split_reg_get_model_from_view (view);
new_amount = input;
acc = gnc_tree_model_split_reg_get_anchor (model);
xfer_acc = xaccSplitGetAccount (split);
xfer_com = xaccAccountGetCommodity (xfer_acc);
reg_com = xaccAccountGetCommodity (acc);
curr = xaccTransGetCurrency (trans);
if (!xaccTransGetRateForCommodity (trans, reg_com, NULL, &convrate))
convrate = gnc_numeric_create (100, 100);
amtconv = convrate;
if (gnc_tree_util_split_reg_needs_conv_rate (view, trans, acc))
{
/* If we are in an expanded register and the xfer_acc->comm !=
* reg_acc->comm then we need to compute the convrate here.
* Otherwise, we _can_ use the rate_cell!
*/
if (gnc_commodity_equal (reg_com, xfer_com))
amtconv = xaccTransGetAccountConvRate (trans, acc);
}
if (xaccTransUseTradingAccounts (trans))
{
/* Using currency accounts, the amount is probably really the
amount and not the value. */
gboolean is_amount;
if (model->type == STOCK_REGISTER2 ||
model->type == CURRENCY_REGISTER2 ||
model->type == PORTFOLIO_LEDGER2)
{
if (xaccAccountIsPriced (xfer_acc) ||
!gnc_commodity_is_iso (xaccAccountGetCommodity (xfer_acc)))
is_amount = FALSE;
else
is_amount = TRUE;
}
else
{
is_amount = TRUE;
}
if (is_amount)
{
xaccSplitSetAmount (split, new_amount);
if (gnc_tree_util_split_reg_needs_amount (view, split))
{
value = gnc_numeric_div (new_amount, amtconv,
gnc_commodity_get_fraction (curr),
GNC_HOW_RND_ROUND_HALF_UP);
xaccSplitSetValue (split, value);
}
else
xaccSplitSetValue (split, new_amount);
}
else
{
xaccSplitSetValue (split, new_amount);
}
LEAVE(" ");
return;
}
/* How to interpret new_amount depends on our view of this
* transaction. If we're sitting in an account with the same
* commodity as the transaction, then we can set the Value and then
* compute the amount. Otherwise we are setting the "converted
* value". This means we need to convert new_amount to the actual
* 'value' by dividing by the convrate in order to set the value.
*/
/* Now compute/set the split value. Amount is in the register
* currency but we need to convert to the txn currency.
*/
if (gnc_tree_util_split_reg_needs_conv_rate (view, trans, acc))
{
/* convert the amount to the Value ... */
value = gnc_numeric_div (new_amount, amtconv,
gnc_commodity_get_fraction (curr),
GNC_HOW_RND_ROUND_HALF_UP);
xaccSplitSetValue (split, value);
}
else
{
xaccSplitSetValue (split, new_amount);
}
/* Now re-compute the Amount from the Value. We may need to convert
* from the Value back to the amount here using the convrate from
* earlier.
*/
value = xaccSplitGetValue (split);
if (gnc_tree_util_split_reg_needs_amount (view, split))
{
acc = xaccSplitGetAccount (split);
new_amount = gnc_numeric_mul (value, convrate,
xaccAccountGetCommoditySCU (acc),
GNC_HOW_RND_ROUND_HALF_UP);
xaccSplitSetAmount (split, new_amount);
}
else
{
xaccSplitSetAmount (split, value);
}
LEAVE(" ");
}
/* Takes the input with column and sets the price / amount / value so they are consistent */
void
gnc_tree_util_set_number_for_input (GncTreeViewSplitReg *view, Transaction *trans, Split *split, gnc_numeric input, gint viewcol)
{
GncTreeModelSplitReg *model;
gnc_numeric price;
gnc_numeric amount;
gnc_numeric value;
gboolean price_changed = FALSE; // Price of each share
gboolean value_changed = FALSE; // Total value of shares
gboolean amount_changed = FALSE; // No of shares
gboolean recalc_amount = FALSE;
gboolean recalc_price = FALSE;
gboolean recalc_value = FALSE;
gboolean expanded = FALSE;
int denom;
Account *account = NULL;
ENTER("trans %p and split %p and input is %s and viewcol is %d", trans, split, gnc_numeric_to_string (input), viewcol);
model = gnc_tree_view_split_reg_get_model_from_view (view);
/* Check for sub account view */
if (!gnc_tree_model_split_reg_get_sub_account (model))
account = gnc_tree_model_split_reg_get_anchor (model);
expanded = gnc_tree_view_split_reg_trans_expanded (view, trans);
if (!account)
account = xaccSplitGetAccount (split);
if (!xaccAccountIsPriced (account))
return;
/* If we are using commodity trading accounts then the value may
not really be the value. Punt if so. */
if (xaccTransUseTradingAccounts (xaccSplitGetParent (split)))
{
gnc_commodity *acc_commodity;
acc_commodity = xaccAccountGetCommodity (account);
if (!(xaccAccountIsPriced (account) || !gnc_commodity_is_iso (acc_commodity)))
return;
}
if (gnc_numeric_zero_p (input))
{
xaccSplitSetValue (split, input);
xaccSplitSetAmount (split, input);
LEAVE("zero");
return;
}
amount = xaccSplitGetAmount (split);
value = xaccSplitGetValue (split);
if (viewcol == COL_AMTVAL && !expanded)
{
value_changed = TRUE;
if (gnc_numeric_zero_p (amount))
{
xaccSplitSetValue (split, input);
xaccSplitSetAmount (split, input);
LEAVE("");
return;
}
}
else if (viewcol == COL_AMTVAL && expanded)
{
amount_changed = TRUE;
if (gnc_numeric_zero_p (value))
{
xaccSplitSetValue (split, input);
xaccSplitSetAmount (split, input);
LEAVE("");
return;
}
}
if (viewcol == COL_PRICE)
{
price_changed = TRUE;
if (gnc_numeric_zero_p (value))
{
amount = gnc_numeric_create (1,1);
value = gnc_numeric_mul (input, amount, GNC_DENOM_AUTO, GNC_HOW_RND_ROUND);
xaccSplitSetValue (split, input);
xaccSplitSetAmount (split, amount);
LEAVE("");
return;
}
}
if ((viewcol == COL_CREDIT || viewcol == COL_DEBIT) && !expanded)
{
amount_changed = TRUE;
if (gnc_numeric_zero_p (value))
{
xaccSplitSetValue (split, input);
xaccSplitSetAmount (split, input);
LEAVE("");
return;
}
}
else if ((viewcol == COL_CREDIT || viewcol == COL_DEBIT) && expanded)
{
value_changed = TRUE;
if (gnc_numeric_zero_p (value))
{
xaccSplitSetValue (split, input);
xaccSplitSetAmount (split, input);
LEAVE("");
return;
}
}
DEBUG("value_changed %d, price_changed %d, amount_changed %d", value_changed, price_changed, amount_changed);
{
int choice;
int default_value;
GList *node;
GList *radio_list = NULL;
const char *title = _("Recalculate Transaction");
const char *message = _("The values entered for this transaction "
"are inconsistent. Which value would you "
"like to have recalculated?");
if (amount_changed)
radio_list = g_list_append (radio_list,
g_strdup_printf ("%s (%s)",
_("_Shares"), _("Changed")));
else
radio_list = g_list_append (radio_list, g_strdup (_("_Shares")));
if (price_changed)
radio_list = g_list_append (radio_list,
g_strdup_printf ("%s (%s)",
_("_Price"), _("Changed")));
else
radio_list = g_list_append (radio_list, g_strdup (_("_Price")));
if (value_changed)
radio_list = g_list_append (radio_list,
g_strdup_printf ("%s (%s)",
_("_Value"), _("Changed")));
else
radio_list = g_list_append (radio_list, g_strdup (_("_Value")));
if(expanded)
{
if (price_changed)
default_value = 2; /* change the value */
else
default_value = 1; /* change the price */
}
else
{
if (price_changed)
default_value = 0; /* change the amount / shares */
else
default_value = 1; /* change the price */
}
choice = gnc_choose_radio_option_dialog
(gnc_tree_view_split_reg_get_parent (view),
title,
message,
_("_Recalculate"),
default_value,
radio_list);
for (node = radio_list; node; node = node->next)
g_free (node->data);
g_list_free (radio_list);
switch (choice)
{
case 0: /* Modify number of shares */
recalc_amount = TRUE;
break;
case 1: /* Modify the share price */
recalc_price = TRUE;
break;
case 2: /* Modify total value */
recalc_value = TRUE;
break;
default: /* Cancel */
LEAVE(" " );
return;
}
}
DEBUG("recalc_value %d, recalc_price %d, recalc_amount %d", recalc_value, recalc_price, recalc_amount);
if (recalc_amount)
{
denom = gtu_sr_get_amount_denom (split);
if (amount_changed)
{
LEAVE("");
return;
}
if (price_changed)
price = input;
else
price = gnc_numeric_div (value, amount, GNC_DENOM_AUTO, GNC_HOW_DENOM_EXACT);
if (value_changed)
{
xaccSplitSetValue (split, input);
amount = gnc_numeric_div (input, price, denom, GNC_HOW_RND_ROUND_HALF_UP);
xaccSplitSetAmount (split, amount);
}
else
{
amount = gnc_numeric_div (value, price, denom, GNC_HOW_RND_ROUND_HALF_UP);
xaccSplitSetAmount (split, amount);
}
}
if (recalc_price)
{
if (price_changed)
{
LEAVE("");
return;
}
if (amount_changed)
{
xaccSplitSetAmount (split, input);
xaccSplitSetValue (split, value);
}
if (value_changed)
{
xaccSplitSetValue (split, input);
xaccSplitSetAmount (split, amount);
}
}
if (recalc_value)
{
denom = gtu_sr_get_value_denom (split);
if (value_changed)
{
LEAVE("");
return;
}
if (price_changed)
price = input;
else
price = gnc_numeric_div (value, amount, GNC_DENOM_AUTO, GNC_HOW_DENOM_EXACT);
if (amount_changed)
{
xaccSplitSetAmount (split, input);
value = gnc_numeric_mul (input, price, denom, GNC_HOW_RND_ROUND_HALF_UP);
xaccSplitSetValue (split, value);
}
else
{
value = gnc_numeric_mul (amount, price, denom, GNC_HOW_RND_ROUND_HALF_UP);
xaccSplitSetValue (split, value);
}
}
/* If the number of splits is two, change other split to balance */
if (!gnc_tree_util_split_reg_is_multi (split) && expanded)
{
Split *osplit;
gnc_commodity *osplit_com;
osplit = xaccSplitGetOtherSplit (split);
value = xaccSplitGetValue (split);
osplit_com = xaccAccountGetCommodity (xaccSplitGetAccount (osplit));
if (gnc_commodity_is_currency (osplit_com))
{
xaccSplitSetValue (osplit, gnc_numeric_neg (value));
xaccSplitSetAmount (osplit, gnc_numeric_neg (value));
}
}
LEAVE("");
}
