static gint
default_sort (gnc_commodity *comm_a, gnc_commodity *comm_b)
{
gint fraction_a, fraction_b, result;
result = safe_utf8_collate (gnc_commodity_get_namespace (comm_a),
gnc_commodity_get_namespace (comm_b));
if (result != 0) return result;
result = safe_utf8_collate (gnc_commodity_get_mnemonic (comm_a),
gnc_commodity_get_mnemonic (comm_b));
if (result != 0) return result;
result = safe_utf8_collate (gnc_commodity_get_fullname (comm_a),
gnc_commodity_get_fullname (comm_b));
if (result != 0) return result;
result = safe_utf8_collate (gnc_commodity_get_cusip (comm_a),
gnc_commodity_get_cusip (comm_b));
if (result != 0) return result;
fraction_a = gnc_commodity_get_fraction (comm_a);
fraction_b = gnc_commodity_get_fraction (comm_b);
if (fraction_a < fraction_b)
return -1;
if (fraction_b < fraction_a)
return 1;
return 0;
}
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);
}
}
static void
calculate_selected_total_helper (GtkTreeModel *model,
GtkTreePath *path,
GtkTreeIter *iter,
gpointer data)
{
gnc_numeric *subtotal = (gnc_numeric*) data;
gnc_numeric cur_val;
GValue value = { 0 };
GNCLot *lot;
Account *acct;
gnc_commodity *currency;
gtk_tree_model_get_value (model, iter, 5, &value);
lot = (GNCLot *) g_value_get_pointer (&value);
g_value_unset (&value);
/* Find the amount's currency to determine the required precision */
acct = gnc_lot_get_account (lot);
currency = xaccAccountGetCommodity (acct);
cur_val = gnc_lot_get_balance (lot);
*subtotal = gnc_numeric_add (*subtotal, cur_val,
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;
}
/* Returns the value denom */
static int
gtu_sr_get_value_denom (Split *split)
{
gnc_commodity *currency;
int denom;
currency = xaccTransGetCurrency (xaccSplitGetParent (split));
denom = gnc_commodity_get_fraction (currency);
if (denom == 0)
{
gnc_commodity *commodity = gnc_default_currency ();
denom = gnc_commodity_get_fraction (commodity);
if (denom == 0)
denom = 100;
}
return denom;
}
static gnc_numeric
gnc_transaction_adjust_trading_splits (Transaction* trans, Account *root)
{
GList* splits;
gnc_numeric imbalance = gnc_numeric_zero();
for (splits = trans->splits; splits; splits = splits->next)
{
Split *split = splits->data;
Split *balance_split = NULL;
gnc_numeric value, amount;
gnc_commodity *commodity, *txn_curr = xaccTransGetCurrency (trans);
if (! xaccTransStillHasSplit (trans, split)) continue;
commodity = xaccAccountGetCommodity (xaccSplitGetAccount(split));
if (!commodity)
{
PERR("Split has no commodity");
continue;
}
balance_split = find_trading_split (trans, root, commodity);
if (balance_split != split)
/* this is not a trading split */
imbalance = gnc_numeric_add(imbalance, xaccSplitGetValue (split),
GNC_DENOM_AUTO, GNC_HOW_DENOM_EXACT);
/* Ignore splits where value or amount is zero */
value = xaccSplitGetValue (split);
amount = xaccSplitGetAmount (split);
if (gnc_numeric_zero_p(amount) || gnc_numeric_zero_p(value))
continue;
if (balance_split && balance_split != split)
{
gnc_numeric convrate = gnc_numeric_div (amount, value,
GNC_DENOM_AUTO, GNC_HOW_DENOM_REDUCE);
gnc_numeric old_value, new_value;
old_value = xaccSplitGetValue(balance_split);
new_value = gnc_numeric_div (xaccSplitGetAmount(balance_split),
convrate,
gnc_commodity_get_fraction(txn_curr),
GNC_HOW_RND_ROUND_HALF_UP);
if (! gnc_numeric_equal (old_value, new_value))
{
xaccTransBeginEdit (trans);
xaccSplitSetValue (balance_split, new_value);
xaccSplitScrub (balance_split);
xaccTransCommitEdit (trans);
}
}
}
return imbalance;
}
/*
* Given an owner, extract the open balance from the owner and then
* convert it to the desired currency.
*/
gnc_numeric
gncOwnerGetBalanceInCurrency (const GncOwner *owner,
const gnc_commodity *report_currency)
{
gnc_numeric balance = gnc_numeric_zero ();
GList *acct_list, *acct_node, *acct_types, *lot_list = NULL, *lot_node;
QofBook *book;
gnc_commodity *owner_currency;
GNCPriceDB *pdb;
g_return_val_if_fail (owner, gnc_numeric_zero ());
/* Get account list */
book = qof_instance_get_book (qofOwnerGetOwner (owner));
acct_list = gnc_account_get_descendants (gnc_book_get_root_account (book));
acct_types = gncOwnerGetAccountTypesList (owner);
owner_currency = gncOwnerGetCurrency (owner);
/* For each account */
for (acct_node = acct_list; acct_node; acct_node = acct_node->next)
{
Account *account = acct_node->data;
/* Check if this account can have lots for the owner, otherwise skip to next */
if (g_list_index (acct_types, (gpointer)xaccAccountGetType (account))
== -1)
continue;
if (!gnc_commodity_equal (owner_currency, xaccAccountGetCommodity (account)))
continue;
/* Get a list of open lots for this owner and account */
lot_list = xaccAccountFindOpenLots (account, gncOwnerLotMatchOwnerFunc,
(gpointer)owner, NULL);
/* For each lot */
for (lot_node = lot_list; lot_node; lot_node = lot_node->next)
{
GNCLot *lot = lot_node->data;
gnc_numeric lot_balance = gnc_lot_get_balance (lot);
GncInvoice *invoice = gncInvoiceGetInvoiceFromLot(lot);
if (invoice)
balance = gnc_numeric_add (balance, lot_balance,
gnc_commodity_get_fraction (owner_currency), GNC_HOW_RND_ROUND_HALF_UP);
}
}
pdb = gnc_pricedb_get_db (book);
if (report_currency)
balance = gnc_pricedb_convert_balance_latest_price (
pdb, balance, owner_currency, report_currency);
return balance;
}
static int
get_entry_commodity_denom (const GncEntry *entry)
{
gnc_commodity *c;
if (!entry)
return 0;
if (entry->invoice)
{
c = gncInvoiceGetCurrency (entry->invoice);
if (c)
return (gnc_commodity_get_fraction (c));
}
if (entry->bill)
{
c = gncInvoiceGetCurrency (entry->bill);
if (c)
return (gnc_commodity_get_fraction (c));
}
return 100000;
}
/** Balance the transaction by adding more trading splits. This shouldn't
* ordinarily be necessary.
* @param trans the transaction to balance
* @param root the root account
*/
static void
gnc_transaction_balance_trading_more_splits (Transaction *trans, Account *root)
{
/* Copy the split list so we don't see the splits we're adding */
GList *splits_dup = g_list_copy(trans->splits), *splits = NULL;
const gnc_commodity *txn_curr = xaccTransGetCurrency (trans);
for (splits = splits_dup; splits; splits = splits->next)
{
Split *split = splits->data;
if (! xaccTransStillHasSplit(trans, split)) continue;
if (!gnc_numeric_zero_p(xaccSplitGetValue(split)) &&
gnc_numeric_zero_p(xaccSplitGetAmount(split)))
{
gnc_commodity *commodity;
gnc_numeric old_value, new_value;
Split *balance_split;
Account *account = NULL;
commodity = xaccAccountGetCommodity(xaccSplitGetAccount(split));
if (!commodity)
{
PERR("Split has no commodity");
continue;
}
balance_split = get_trading_split(trans, root, commodity);
if (!balance_split)
{
/* Error already logged */
LEAVE("");
return;
}
account = xaccSplitGetAccount(balance_split);
xaccTransBeginEdit (trans);
old_value = xaccSplitGetValue (balance_split);
new_value = gnc_numeric_sub (old_value, xaccSplitGetValue(split),
gnc_commodity_get_fraction(txn_curr),
GNC_HOW_RND_ROUND_HALF_UP);
xaccSplitSetValue (balance_split, new_value);
/* Don't change the balance split's amount since the amount
is zero in the split we're working on */
xaccSplitScrub (balance_split);
xaccTransCommitEdit (trans);
}
}
g_list_free(splits_dup);
}
static gint
sort_by_fraction (GtkTreeModel *f_model,
GtkTreeIter *f_iter_a,
GtkTreeIter *f_iter_b,
gpointer user_data)
{
gnc_commodity *comm_a, *comm_b;
gint fraction_a, fraction_b;
if (!get_commodities (f_model, f_iter_a, f_iter_b, NULL, &comm_a, &comm_b))
return sort_namespace (f_model, f_iter_a, f_iter_b);
fraction_a = gnc_commodity_get_fraction (comm_a);
fraction_b = gnc_commodity_get_fraction (comm_b);
if (fraction_a < fraction_b)
return -1;
if (fraction_b < fraction_a)
return 1;
return default_sort(comm_a, comm_b);
}
/* Copy the values in the financial_info structure to the GUI */
static void
fi_to_gui(FinCalcDialog *fcd)
{
const gnc_commodity *commodity;
static char string[64];
gnc_numeric total;
gnc_numeric npp;
gnc_numeric pmt;
int i;
if (fcd == NULL)
return;
npp = gnc_numeric_create (fcd->financial_info.npp, 1);
gnc_amount_edit_set_amount (GNC_AMOUNT_EDIT(fcd->amounts[PAYMENT_PERIODS]),
npp);
gnc_amount_edit_set_damount (GNC_AMOUNT_EDIT(fcd->amounts[INTEREST_RATE]),
fcd->financial_info.ir);
gnc_amount_edit_set_damount (GNC_AMOUNT_EDIT(fcd->amounts[PRESENT_VALUE]),
fcd->financial_info.pv);
gnc_amount_edit_set_damount (GNC_AMOUNT_EDIT(fcd->amounts[PERIODIC_PAYMENT]),
fcd->financial_info.pmt);
gnc_amount_edit_set_damount (GNC_AMOUNT_EDIT(fcd->amounts[FUTURE_VALUE]),
-fcd->financial_info.fv);
pmt = double_to_gnc_numeric (fcd->financial_info.pmt, 100000, GNC_HOW_RND_ROUND_HALF_UP);
commodity = gnc_default_currency ();
total = gnc_numeric_mul (npp, pmt, gnc_commodity_get_fraction (commodity),
GNC_HOW_RND_ROUND_HALF_UP);
xaccSPrintAmount (string, total, gnc_default_print_info (FALSE));
gtk_label_set_text (GTK_LABEL(fcd->payment_total_label), string);
i = normalize_period(&fcd->financial_info.CF);
gtk_combo_box_set_active(GTK_COMBO_BOX(fcd->compounding_combo), i);
i = normalize_period(&fcd->financial_info.PF);
gtk_combo_box_set_active(GTK_COMBO_BOX(fcd->payment_combo), i);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(fcd->end_of_period_radio),
!fcd->financial_info.bep);
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON(fcd->discrete_compounding_radio),
fcd->financial_info.disc);
}
SCM gnc_account_value_ptr_to_scm (GncAccountValue *av)
{
swig_type_info * account_type = get_acct_type();
gnc_commodity * com;
gnc_numeric val;
if (!av) return SCM_BOOL_F;
com = xaccAccountGetCommodity (av->account);
val = gnc_numeric_convert (av->value, gnc_commodity_get_fraction (com),
GNC_HOW_RND_ROUND_HALF_UP);
return scm_cons (SWIG_NewPointerObj(av->account, account_type, 0),
gnc_numeric_to_scm (val));
}
/* Returns the amount denom */
static int
gtu_sr_get_amount_denom (Split *split)
{
int denom;
denom = xaccAccountGetCommoditySCU (xaccSplitGetAccount (split));
if (denom == 0)
{
gnc_commodity *commodity = gnc_default_currency ();
denom = gnc_commodity_get_fraction (commodity);
if (denom == 0)
denom = 100;
}
return denom;
}
/** Initialize an edit field that will display a number in the users
* local currency.
*
* @param edit A pointer to the edit widget.
*/
static void
fincalc_init_commodity_gae (GNCAmountEdit *edit)
{
GNCPrintAmountInfo print_info;
gnc_commodity *commodity;
gint fraction;
commodity = gnc_default_currency();
fraction = gnc_commodity_get_fraction(commodity);
print_info = gnc_commodity_print_info (commodity, FALSE);
gnc_amount_edit_set_print_info (edit, print_info);
gnc_amount_edit_set_fraction (edit, fraction);
gnc_amount_edit_set_evaluate_on_enter (edit, TRUE);
gtk_entry_set_alignment (GTK_ENTRY(edit), 1.0);
}
static gboolean
valid_commodity(gnc_commodity *com)
{
if (gnc_commodity_get_namespace(com) == NULL)
{
PWARN("Invalid commodity: no namespace");
return FALSE;
}
if (gnc_commodity_get_mnemonic(com) == NULL)
{
PWARN("Invalid commodity: no mnemonic");
return FALSE;
}
if (gnc_commodity_get_fraction(com) == 0)
{
PWARN("Invalid commodity: 0 fraction");
return FALSE;
}
return TRUE;
}
void
gnc_payment_leave_amount_cb (GtkWidget *widget, GdkEventFocus *event,
PaymentWindow *pw)
{
gnc_numeric amount_deb, amount_cred, amount_tot;
if (! pw->amount_credit_edit || ! pw->amount_debit_edit)
return;
/* If both credit and debit amount are entered, simplify it to either one */
amount_deb = gnc_amount_edit_get_amount (GNC_AMOUNT_EDIT (pw->amount_debit_edit));
amount_cred = gnc_amount_edit_get_amount (GNC_AMOUNT_EDIT (pw->amount_credit_edit));
amount_tot = gnc_numeric_sub (amount_cred, amount_deb,
gnc_commodity_get_fraction (xaccAccountGetCommodity (pw->post_acct)),
GNC_HOW_RND_ROUND_HALF_UP);
gnc_ui_payment_window_set_amount (pw, amount_tot);
/* Reflect if the payment could complete now */
gnc_payment_window_check_payment (pw);
}
static void
add_balance_split (Transaction *trans, gnc_numeric imbalance,
Account *root, Account *account)
{
const gnc_commodity *commodity;
gnc_numeric old_value, new_value;
Split *balance_split;
gnc_commodity *currency = xaccTransGetCurrency (trans);
balance_split = get_balance_split(trans, root, account, currency);
if (!balance_split)
{
/* Error already logged */
LEAVE("");
return;
}
account = xaccSplitGetAccount(balance_split);
xaccTransBeginEdit (trans);
old_value = xaccSplitGetValue (balance_split);
/* Note: We have to round for the commodity's fraction, NOT any
* already existing denominator (bug #104343), because either one
* of the denominators might already be reduced. */
new_value = gnc_numeric_sub (old_value, imbalance,
gnc_commodity_get_fraction(currency),
GNC_HOW_RND_ROUND_HALF_UP);
xaccSplitSetValue (balance_split, new_value);
commodity = xaccAccountGetCommodity (account);
if (gnc_commodity_equiv (currency, commodity))
{
xaccSplitSetAmount (balance_split, new_value);
}
xaccSplitScrub (balance_split);
xaccTransCommitEdit (trans);
}
gboolean
gnc_tree_util_split_reg_get_debcred_entry (GncTreeViewSplitReg *view,
Transaction *trans, Split *split,
gboolean is_blank, gnc_numeric *ret_num,
GNCPrintAmountInfo *ret_print_info)
{
GncTreeModelSplitReg *model;
gnc_commodity *currency;
model = gnc_tree_view_split_reg_get_model_from_view (view);
currency = xaccTransGetCurrency (trans);
if (!currency)
currency = gnc_default_currency ();
if (is_blank)
{
gnc_numeric imbalance;
Account *acc;
imbalance = xaccTransGetImbalanceValue (trans);
if (gnc_numeric_zero_p (imbalance))
return FALSE;
if (xaccTransUseTradingAccounts (trans))
{
MonetaryList *imbal_list;
gnc_monetary *imbal_mon;
imbal_list = xaccTransGetImbalance (trans);
if (!imbal_list)
{
/* No commodity imbalance, there shouldn't be a value imablance. */
return FALSE;
}
if (imbal_list->next)
{
/* Multiple currency imbalance. */
gnc_monetary_list_free (imbal_list);
return FALSE;
}
imbal_mon = imbal_list->data;
if (!gnc_commodity_equal (gnc_monetary_commodity (*imbal_mon), currency))
{
/* Imbalance is in wrong currency */
gnc_monetary_list_free (imbal_list);
return FALSE;
}
if (!gnc_numeric_equal (gnc_monetary_value (*imbal_mon), imbalance))
{
/* Value and commodity imbalances differ */
gnc_monetary_list_free (imbal_list);
return FALSE;
}
/* Done with the imbalance list */
gnc_monetary_list_free (imbal_list);
}
imbalance = gnc_numeric_neg (imbalance);
acc = gnc_tree_model_split_reg_get_anchor (model);
if (gnc_tree_util_split_reg_needs_conv_rate (view, trans, acc))
{
imbalance = gnc_numeric_mul (imbalance,
xaccTransGetAccountConvRate (trans, acc),
gnc_commodity_get_fraction (currency),
GNC_HOW_RND_ROUND_HALF_UP);
}
else
{
imbalance = gnc_numeric_convert (imbalance,
gnc_commodity_get_fraction (currency),
GNC_HOW_RND_ROUND_HALF_UP);
}
*ret_num = imbalance;
*ret_print_info = gnc_account_print_info (acc, FALSE);
return TRUE;
}
{
gnc_numeric amount;
gnc_commodity *split_commodity;
GNCPrintAmountInfo print_info;
Account *account;
gnc_commodity *commodity;
account = gnc_tree_model_split_reg_get_anchor (model);
commodity = xaccAccountGetCommodity (account);
split_commodity = xaccAccountGetCommodity (xaccSplitGetAccount (split));
if (xaccTransUseTradingAccounts (trans))
{
gboolean use_symbol, is_current = FALSE;
Split *current_split = gnc_tree_view_split_reg_get_current_split (view);
RowDepth depth = gnc_tree_view_reg_get_selected_row_depth (view);
if ((split == current_split) && (depth == SPLIT3))
is_current = TRUE;
if (model->type == STOCK_REGISTER2 ||
model->type == CURRENCY_REGISTER2 ||
model->type == PORTFOLIO_LEDGER2)
{
gnc_commodity *amount_commodity;
/* security register. If this split has price and shares columns,
use the value, otherwise use the amount. */
if (gtu_sr_use_security (view))
{
amount = xaccSplitGetValue (split);
amount_commodity = currency;
}
else
{
amount = xaccSplitGetAmount (split);
amount_commodity = split_commodity;
}
/* Show the currency if it is not the default currency */
if (is_current ||
gnc_commodity_equiv (amount_commodity, gnc_default_currency ()))
use_symbol = FALSE;
else
use_symbol = TRUE;
print_info = gnc_commodity_print_info (amount_commodity, use_symbol);
}
else
{
/* non-security register, always use the split amount. */
amount = xaccSplitGetAmount (split);
if (is_current ||
gnc_commodity_equiv (split_commodity, commodity))
use_symbol = FALSE;
else
use_symbol = TRUE;
print_info = gnc_commodity_print_info (split_commodity, use_symbol);
}
}
else
{
/* If this account is not a stock/mutual/currency account, and
* currency != the account commodity, then use the SplitAmount
* instead of the SplitValue.
*/
switch (model->type)
{
case STOCK_REGISTER2:
case CURRENCY_REGISTER2:
case PORTFOLIO_LEDGER2:
amount = xaccSplitGetValue (split);
print_info = gnc_commodity_print_info (currency, FALSE);
break;
default:
if (commodity && !gnc_commodity_equal (commodity, currency))
/* Convert this to the "local" value */
amount = xaccSplitConvertAmount (split, account);
else
amount = xaccSplitGetValue (split);
print_info = gnc_account_print_info (account, FALSE);
break;
}
}
if (gnc_numeric_zero_p (amount))
return FALSE;
*ret_num = amount;
*ret_print_info = print_info;
return TRUE;
}
}
static void
gnc_transaction_balance_trading (Transaction *trans, Account *root)
{
MonetaryList *imbal_list;
MonetaryList *imbalance_commod;
Split *balance_split = NULL;
/* If the transaction is balanced, nothing more to do */
imbal_list = xaccTransGetImbalance (trans);
if (!imbal_list)
{
LEAVE("transaction is balanced");
return;
}
PINFO ("Currency unbalanced transaction");
for (imbalance_commod = imbal_list; imbalance_commod;
imbalance_commod = imbalance_commod->next)
{
gnc_monetary *imbal_mon = imbalance_commod->data;
gnc_commodity *commodity;
gnc_numeric old_amount, new_amount;
gnc_numeric old_value, new_value, val_imbalance;
Account *account = NULL;
const gnc_commodity *txn_curr = xaccTransGetCurrency (trans);
commodity = gnc_monetary_commodity (*imbal_mon);
balance_split = get_trading_split(trans, root, commodity);
if (!balance_split)
{
/* Error already logged */
gnc_monetary_list_free(imbal_list);
LEAVE("");
return;
}
account = xaccSplitGetAccount(balance_split);
if (! gnc_commodity_equal (txn_curr, commodity))
{
val_imbalance = gnc_transaction_get_commodity_imbalance (trans, commodity);
}
xaccTransBeginEdit (trans);
old_amount = xaccSplitGetAmount (balance_split);
new_amount = gnc_numeric_sub (old_amount, gnc_monetary_value(*imbal_mon),
gnc_commodity_get_fraction(commodity),
GNC_HOW_RND_ROUND_HALF_UP);
xaccSplitSetAmount (balance_split, new_amount);
if (gnc_commodity_equal (txn_curr, commodity))
{
/* Imbalance commodity is the transaction currency, value in the
split must be the same as the amount */
xaccSplitSetValue (balance_split, new_amount);
}
else
{
old_value = xaccSplitGetValue (balance_split);
new_value = gnc_numeric_sub (old_value, val_imbalance,
gnc_commodity_get_fraction(txn_curr),
GNC_HOW_RND_ROUND_HALF_UP);
xaccSplitSetValue (balance_split, new_value);
}
xaccSplitScrub (balance_split);
xaccTransCommitEdit (trans);
}
gnc_monetary_list_free(imbal_list);
}
static gboolean
gnc_payment_window_check_payment (PaymentWindow *pw)
{
const char *conflict_msg = NULL;
Account *post, *acc;
gnc_numeric amount_deb, amount_cred;
gboolean enable_xfer_acct = TRUE;
GtkTreeSelection *selection;
if (!pw)
return FALSE;
/* Verify the "post" account */
if (!pw->post_acct)
{
conflict_msg = _("You must enter a valid account name for posting.");
goto update_cleanup;
}
/* Verify the user has selected an owner */
gnc_owner_get_owner (pw->owner_choice, &(pw->owner));
if (!gncOwnerIsValid(&pw->owner))
{
conflict_msg = _("You must select a company for payment processing.");
goto update_cleanup;
}
/* Test the total amount */
amount_deb = gnc_amount_edit_get_amount (GNC_AMOUNT_EDIT (pw->amount_debit_edit));
amount_cred = gnc_amount_edit_get_amount (GNC_AMOUNT_EDIT (pw->amount_credit_edit));
pw->amount_tot = gnc_numeric_sub (amount_cred, amount_deb,
gnc_commodity_get_fraction (xaccAccountGetCommodity (pw->post_acct)),
GNC_HOW_RND_ROUND_HALF_UP);
if (gnc_numeric_check (pw->amount_tot) || gnc_numeric_zero_p (pw->amount_tot))
{
enable_xfer_acct = FALSE;
}
else
{
/* Verify the user has selected a transfer account */
pw->xfer_acct = gnc_tree_view_account_get_selected_account (GNC_TREE_VIEW_ACCOUNT(pw->acct_tree));
if (!pw->xfer_acct)
{
conflict_msg = _("You must select a transfer account from the account tree.");
}
}
update_cleanup:
gtk_widget_set_sensitive (pw->acct_tree, enable_xfer_acct);
/* Check if there are issues preventing a successful payment */
gtk_widget_set_tooltip_text (pw->payment_warning, conflict_msg);
if (conflict_msg)
{
gtk_widget_show (pw->payment_warning);
gtk_widget_set_sensitive (pw->ok_button, FALSE);
return FALSE;
}
else
{
gtk_widget_hide (pw->payment_warning);
gtk_widget_set_sensitive (pw->ok_button, TRUE);
}
return TRUE;
}
void
xaccSplitScrub (Split *split)
{
Account *account;
Transaction *trans;
gnc_numeric value, amount;
gnc_commodity *currency, *acc_commodity;
int scu;
if (!split) return;
ENTER ("(split=%p)", split);
trans = xaccSplitGetParent (split);
if (!trans)
{
LEAVE("no trans");
return;
}
account = xaccSplitGetAccount (split);
/* If there's no account, this split is an orphan.
* We need to fix that first, before proceeding.
*/
if (!account)
{
xaccTransScrubOrphans (trans);
account = xaccSplitGetAccount (split);
}
/* Grrr... the register gnc_split_register_load() line 203 of
* src/register/ledger-core/split-register-load.c will create
* free-floating bogus transactions. Ignore these for now ...
*/
if (!account)
{
PINFO ("Free Floating Transaction!");
LEAVE ("no account");
return;
}
/* Split amounts and values should be valid numbers */
value = xaccSplitGetValue (split);
if (gnc_numeric_check (value))
{
value = gnc_numeric_zero();
xaccSplitSetValue (split, value);
}
amount = xaccSplitGetAmount (split);
if (gnc_numeric_check (amount))
{
amount = gnc_numeric_zero();
xaccSplitSetAmount (split, amount);
}
currency = xaccTransGetCurrency (trans);
/* If the account doesn't have a commodity,
* we should attempt to fix that first.
*/
acc_commodity = xaccAccountGetCommodity(account);
if (!acc_commodity)
{
xaccAccountScrubCommodity (account);
}
if (!acc_commodity || !gnc_commodity_equiv(acc_commodity, currency))
{
LEAVE ("(split=%p) inequiv currency", split);
return;
}
scu = MIN (xaccAccountGetCommoditySCU (account),
gnc_commodity_get_fraction (currency));
if (gnc_numeric_same (amount, value, scu, GNC_HOW_RND_ROUND_HALF_UP))
{
LEAVE("(split=%p) different values", split);
return;
}
/*
* This will be hit every time you answer yes to the dialog "The
* current transaction has changed. Would you like to record it.
*/
PINFO ("Adjusted split with mismatched values, desc=\"%s\" memo=\"%s\""
" old amount %s %s, new amount %s",
trans->description, split->memo,
gnc_num_dbg_to_string (xaccSplitGetAmount(split)),
gnc_commodity_get_mnemonic (currency),
gnc_num_dbg_to_string (xaccSplitGetValue(split)));
xaccTransBeginEdit (trans);
xaccSplitSetAmount (split, value);
xaccTransCommitEdit (trans);
LEAVE ("(split=%p)", split);
}
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);
}
}
static void
gnc_split_register_save_cells (gpointer save_data,
gpointer user_data)
{
SRSaveData *sd = save_data;
SplitRegister *reg = user_data;
Split *other_split;
gnc_commodity *txn_cur;
gnc_numeric rate = gnc_numeric_zero();
g_return_if_fail (sd != NULL);
if (!sd->do_scrub)
return;
other_split = xaccSplitGetOtherSplit (sd->split);
txn_cur = xaccTransGetCurrency (sd->trans);
xaccSplitScrub (sd->split);
rate = gnc_split_register_get_rate_cell (reg, RATE_CELL);
if (other_split && !sd->reg_expanded)
{
gnc_numeric amount, value = xaccSplitGetValue (sd->split);
Account *acc;
gboolean split_needs_amount;
split_needs_amount = gnc_split_register_split_needs_amount(reg, sd->split);
/* We are changing the rate on the current split, but it was not
* handled in the debcred handler, so we need to do it here.
*/
if (!sd->handled_dc && split_needs_amount && !gnc_numeric_zero_p (rate))
{
gnc_numeric amount = xaccSplitGetAmount (sd->split);
value = gnc_numeric_div(
amount, rate, gnc_commodity_get_fraction(txn_cur), GNC_HOW_RND_ROUND_HALF_UP);
xaccSplitSetValue (sd->split, value);
/* XXX: do we need to set the amount on the other split? */
}
/* Now reverse the value for the other split */
value = gnc_numeric_neg (value);
if (gnc_split_register_split_needs_amount (reg, other_split))
{
acc = xaccSplitGetAccount (other_split);
/* If we don't have an exchange rate then figure it out. Or, if
* BOTH splits require an amount, then most likely we're in the
* strange case of having a transaction currency different than
* _both_ accounts -- so grab the other exchange rate.
*/
if (gnc_numeric_zero_p (rate) || split_needs_amount)
rate = xaccTransGetAccountConvRate(xaccSplitGetParent (other_split),
acc);
amount = gnc_numeric_mul (value, rate, xaccAccountGetCommoditySCU (acc),
GNC_HOW_RND_ROUND_HALF_UP);
xaccSplitSetAmount (other_split, amount);
}
xaccSplitSetValue (other_split, value);
xaccSplitScrub (other_split);
}
else if (gnc_split_register_split_needs_amount (reg, sd->split) &&
! gnc_numeric_zero_p (rate))
{
/* this is either a multi-split or expanded transaction, so only
* deal with this split... In particular we need to reset the
* Value if the conv-rate changed.
*
* If we handled the debcred then no need to do anything there --
* the debcred handler did all the computation. If NOT, then the
* convrate changed -- reset the value from the amount.
*/
if (!sd->handled_dc)
{
gnc_split_register_save_amount_values (sd, reg);
#if 0
gnc_numeric value, amount;
amount = xaccSplitGetAmount (sd->split);
value = gnc_numeric_div (amount, rate, gnc_commodity_get_fraction (txn_cur),
GNC_HOW_RND_ROUND_HALF_UP);
xaccSplitSetValue (sd->split, value);
#endif
}
}
}
/***********************************************************************
* @todo Maybe invoice checking should be done in gnc_bi_import_fix_bis (...)
* rather than in here? But that is more concerned with ensuring the csv is consistent.
* @param GtkListStore *store
* @param guint *n_invoices_created
* @param guint *n_invoices_updated
* @return void
***********************************************************************/
void
gnc_bi_import_create_bis (GtkListStore * store, QofBook * book,
guint * n_invoices_created,
guint * n_invoices_updated,
gchar * type, gchar * open_mode, GString * info)
{
gboolean valid;
GtkTreeIter iter;
gchar *id, *date_opened, *owner_id, *billing_id, *notes;
gchar *date, *desc, *action, *account, *quantity, *price, *disc_type,
*disc_how, *discount, *taxable, *taxincluded, *tax_table;
gchar *date_posted, *due_date, *account_posted, *memo_posted,
*accumulatesplits;
guint dummy;
GncInvoice *invoice;
GncEntry *entry;
gint day, month, year;
gnc_numeric value;
GncOwner *owner;
Account *acc;
enum update {YES = GTK_RESPONSE_YES, NO = GTK_RESPONSE_NO} update;
GtkWidget *dialog;
Timespec today;
InvoiceWindow *iw;
gchar *new_id = NULL;
gint64 denom = 0;
gnc_commodity *currency;
// these arguments are needed
g_return_if_fail (store && book);
// logic of this function only works for bills or invoices
g_return_if_fail ((g_ascii_strcasecmp (type, "INVOICE") == 0) ||
(g_ascii_strcasecmp (type, "BILL") == 0));
// allow to call this function without statistics
if (!n_invoices_created)
n_invoices_created = &dummy;
if (!n_invoices_updated)
n_invoices_updated = &dummy;
*n_invoices_created = 0;
*n_invoices_updated = 0;
invoice = NULL;
update = NO;
valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter);
while (valid)
{
// Walk through the list, reading each row
gtk_tree_model_get (GTK_TREE_MODEL (store), &iter,
ID, &id,
DATE_OPENED, &date_opened,
DATE_POSTED, &date_posted, // if autoposting requested
DUE_DATE, &due_date, // if autoposting requested
ACCOUNT_POSTED, &account_posted, // if autoposting requested
MEMO_POSTED, &memo_posted, // if autoposting requested
ACCU_SPLITS, &accumulatesplits, // if autoposting requested
OWNER_ID, &owner_id,
BILLING_ID, &billing_id,
NOTES, ¬es,
DATE, &date,
DESC, &desc,
ACTION, &action,
ACCOUNT, &account,
QUANTITY, &quantity,
PRICE, &price,
DISC_TYPE, &disc_type,
DISC_HOW, &disc_how,
DISCOUNT, &discount,
TAXABLE, &taxable,
TAXINCLUDED, &taxincluded,
TAX_TABLE, &tax_table, -1);
// TODO: Assign a new invoice number if one is absent. BUT we don't want to assign a new invoice for every line!!
// so we'd have to flag this up somehow or add an option in the import GUI. The former implies that we make
// an assumption about what the importer (person) wants to do. It seems reasonable that a CSV file full of items with
// If an invoice exists then we add to it in this current schema.
// no predefined invoice number is a new invoice that's in need of a new number.
// This was not designed to satisfy the need for repeat invoices however, so maybe we need a another method for this, after all
// It should be easier to copy an invoice with a new ID than to go through all this malarky.
if (g_ascii_strcasecmp (type, "BILL") == 0)
invoice = gnc_search_bill_on_id (book, id);
else if (g_ascii_strcasecmp (type, "INVOICE") == 0)
invoice = gnc_search_invoice_on_id (book, id);
DEBUG( "Existing %s ID: %s\n", type, gncInvoiceGetID(invoice));
// If the search is empty then there is no existing invoice so make a new one
if (invoice == NULL)
{
DEBUG( "Creating a new : %s\n", type );
// new invoice
invoice = gncInvoiceCreate (book);
/* Protect against thrashing the DB and trying to write the invoice
* record prematurely */
gncInvoiceBeginEdit (invoice);
gncInvoiceSetID (invoice, id);
owner = gncOwnerNew ();
if (g_ascii_strcasecmp (type, "BILL") == 0)
gncOwnerInitVendor (owner,
gnc_search_vendor_on_id (book, owner_id));
else if (g_ascii_strcasecmp (type, "INVOICE") == 0)
gncOwnerInitCustomer (owner,
gnc_search_customer_on_id (book, owner_id));
gncInvoiceSetOwner (invoice, owner);
gncInvoiceSetCurrency (invoice, gncOwnerGetCurrency (owner)); // Set the invoice currency based on the owner
if (strlen (date_opened) != 0) // If a date is specified in CSV
{
// FIXME: Must check for the return value of qof_scan_date!
qof_scan_date (date_opened, &day, &month, &year);
gncInvoiceSetDateOpened (invoice,
gnc_dmy2timespec (day, month, year));
}
else // If no date in CSV
{
time64 now = gnc_time (NULL);
Timespec now_timespec;
timespecFromTime64 (&now_timespec, now);
gncInvoiceSetDateOpened (invoice, now_timespec);
}
gncInvoiceSetBillingID (invoice, billing_id ? billing_id : "");
gncInvoiceSetNotes (invoice, notes ? notes : "");
gncInvoiceSetActive (invoice, TRUE);
//if (g_ascii_strcasecmp(type,"INVOICE"))gncInvoiceSetBillTo( invoice, billto );
(*n_invoices_created)++;
update = YES;
// open new bill / invoice in a tab, if requested
if (g_ascii_strcasecmp(open_mode, "ALL") == 0
|| (g_ascii_strcasecmp(open_mode, "NOT_POSTED") == 0
&& strlen(date_posted) == 0))
{
iw = gnc_ui_invoice_edit (invoice);
gnc_plugin_page_invoice_new (iw);
}
gncInvoiceCommitEdit (invoice);
}
// I want to warn the user that an existing billvoice exists, but not every
// time.
// An import can contain many lines usually referring to the same invoice.
// NB: Posted invoices are NEVER updated.
else // if invoice exists
{
if (gncInvoiceIsPosted (invoice)) // Is it already posted?
{
valid =
gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter);
continue; // If already posted then never import
}
if (update != YES) // Pop up a dialog to ask if updates are the expected action
{
dialog = gtk_message_dialog_new (NULL,
GTK_DIALOG_MODAL,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_YES_NO,
"%s",
_("Are you sure you have bills/invoices to update?"));
update = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
if (update == NO)
{
// Cleanup and leave
g_free (id);
g_free (date_opened);
g_free (owner_id);
g_free (billing_id);
g_free (notes);
g_free (date);
g_free (desc);
g_free (action);
g_free (account);
g_free (quantity);
g_free (price);
g_free (disc_type);
g_free (disc_how);
g_free (discount);
g_free (taxable);
g_free (taxincluded);
g_free (tax_table);
g_free (date_posted);
g_free (due_date);
g_free (account_posted);
g_free (memo_posted);
g_free (accumulatesplits);
return;
}
}
(*n_invoices_updated)++;
}
// add entry to invoice/bill
entry = gncEntryCreate (book);
gncEntryBeginEdit(entry);
currency = gncInvoiceGetCurrency(invoice);
if (currency) denom = gnc_commodity_get_fraction(currency);
// FIXME: Must check for the return value of qof_scan_date!
qof_scan_date (date, &day, &month, &year);
{
GDate *date = g_date_new_dmy(day, month, year);
gncEntrySetDateGDate (entry, date);
g_date_free (date);
}
timespecFromTime64 (&today, gnc_time (NULL)); // set today to the current date
gncEntrySetDateEntered (entry, today);
gncEntrySetDescription (entry, desc);
gncEntrySetAction (entry, action);
value = gnc_numeric_zero();
gnc_exp_parser_parse (quantity, &value, NULL);
gncEntrySetQuantity (entry, value);
acc = gnc_account_lookup_for_register (gnc_get_current_root_account (),
account);
if (g_ascii_strcasecmp (type, "BILL") == 0)
{
gncEntrySetBillAccount (entry, acc);
value = gnc_numeric_zero();
gnc_exp_parser_parse (price, &value, NULL);
gncEntrySetBillPrice (entry, value);
gncEntrySetBillTaxable (entry, text2bool (taxable));
gncEntrySetBillTaxIncluded (entry, text2bool (taxincluded));
gncEntrySetBillTaxTable (entry, gncTaxTableLookupByName (book, tax_table));
gncEntryCommitEdit(entry);
gncBillAddEntry (invoice, entry);
}
else if (g_ascii_strcasecmp (type, "INVOICE") == 0)
{
gncEntrySetNotes (entry, notes);
gncEntrySetInvAccount (entry, acc);
value = gnc_numeric_zero();
gnc_exp_parser_parse (price, &value, NULL);
gncEntrySetInvPrice (entry, value);
gncEntrySetInvTaxable (entry, text2bool (taxable));
gncEntrySetInvTaxIncluded (entry, text2bool (taxincluded));
gncEntrySetInvTaxTable (entry, gncTaxTableLookupByName (book, tax_table));
value = gnc_numeric_zero();
gnc_exp_parser_parse (discount, &value, NULL);
gncEntrySetInvDiscount (entry, value);
gncEntrySetInvDiscountType (entry, text2disc_type (disc_type));
gncEntrySetInvDiscountHow (entry, text2disc_how (disc_how));
gncEntryCommitEdit(entry);
gncInvoiceAddEntry (invoice, entry);
}
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter);
// handle auto posting of invoices
if (valid)
gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, ID, &new_id, -1);
if (g_strcmp0 (id, new_id) != 0)
{
// the next invoice id is different => try to autopost this invoice
if (qof_scan_date (date_posted, &day, &month, &year))
{
// autopost this invoice
gboolean auto_pay;
Timespec d1, d2;
if (g_ascii_strcasecmp (type, "INVOICE") == 0)
auto_pay = gnc_prefs_get_bool (GNC_PREFS_GROUP_INVOICE, GNC_PREF_AUTO_PAY);
else
auto_pay = gnc_prefs_get_bool (GNC_PREFS_GROUP_BILL, GNC_PREF_AUTO_PAY);
d1 = gnc_dmy2timespec (day, month, year);
// FIXME: Must check for the return value of qof_scan_date!
qof_scan_date (due_date, &day, &month, &year); // obtains the due date, or leaves it at date_posted
d2 = gnc_dmy2timespec (day, month, year);
acc = gnc_account_lookup_for_register
(gnc_get_current_root_account (), account_posted);
gncInvoicePostToAccount (invoice, acc, &d1, &d2,
memo_posted,
text2bool (accumulatesplits),
auto_pay);
}
}
}
// cleanup
g_free (new_id);
g_free (id);
g_free (date_opened);
g_free (owner_id);
g_free (billing_id);
g_free (notes);
g_free (date);
g_free (desc);
g_free (action);
g_free (account);
g_free (quantity);
g_free (price);
g_free (disc_type);
g_free (disc_how);
g_free (discount);
g_free (taxable);
g_free (taxincluded);
g_free (tax_table);
g_free (date_posted);
g_free (due_date);
g_free (account_posted);
g_free (memo_posted);
g_free (accumulatesplits);
}
void
xaccTransScrubImbalance (Transaction *trans, Account *root,
Account *account)
{
const gnc_commodity *currency;
if (!trans) return;
ENTER ("()");
/* Must look for orphan splits even if there is no imbalance. */
xaccTransScrubSplits (trans);
/* Return immediately if things are balanced. */
if (xaccTransIsBalanced (trans))
{
LEAVE ("transaction is balanced");
return;
}
currency = xaccTransGetCurrency (trans);
if (! xaccTransUseTradingAccounts (trans))
{
gnc_numeric imbalance;
/* Make the value sum to zero */
imbalance = xaccTransGetImbalanceValue (trans);
if (! gnc_numeric_zero_p (imbalance))
{
PINFO ("Value unbalanced transaction");
add_balance_split (trans, imbalance, root, account);
}
}
else
{
MonetaryList *imbal_list;
MonetaryList *imbalance_commod;
GList *splits;
gnc_numeric imbalance;
Split *balance_split = NULL;
/* If there are existing trading splits, adjust the price or exchange
rate in each of them to agree with the non-trading splits for the
same commodity. If there are multiple non-trading splits for the
same commodity in the transaction this will use the exchange rate in
the last such split. This shouldn't happen, and if it does then there's
not much we can do about it anyway.
While we're at it, compute the value imbalance ignoring existing
trading splits. */
imbalance = gnc_numeric_zero();
for (splits = trans->splits; splits; splits = splits->next)
{
Split *split = splits->data;
gnc_numeric value, amount;
gnc_commodity *commodity;
if (! xaccTransStillHasSplit (trans, split)) continue;
commodity = xaccAccountGetCommodity (xaccSplitGetAccount(split));
if (!commodity)
{
PERR("Split has no commodity");
continue;
}
balance_split = find_trading_split (trans, root, commodity);
if (balance_split != split)
/* this is not a trading split */
imbalance = gnc_numeric_add(imbalance, xaccSplitGetValue (split),
GNC_DENOM_AUTO, GNC_HOW_DENOM_EXACT);
/* Ignore splits where value or amount is zero */
value = xaccSplitGetValue (split);
amount = xaccSplitGetAmount (split);
if (gnc_numeric_zero_p(amount) || gnc_numeric_zero_p(value))
continue;
if (balance_split && balance_split != split)
{
gnc_numeric convrate = gnc_numeric_div (amount, value,
GNC_DENOM_AUTO, GNC_HOW_DENOM_REDUCE);
gnc_numeric old_value, new_value;
old_value = xaccSplitGetValue(balance_split);
new_value = gnc_numeric_div (xaccSplitGetAmount(balance_split),
convrate,
gnc_commodity_get_fraction(currency),
GNC_HOW_RND_ROUND_HALF_UP);
if (! gnc_numeric_equal (old_value, new_value))
{
xaccTransBeginEdit (trans);
xaccSplitSetValue (balance_split, new_value);
xaccSplitScrub (balance_split);
xaccTransCommitEdit (trans);
}
}
}
/* Balance the value, ignoring existing trading splits */
if (! gnc_numeric_zero_p (imbalance))
{
PINFO ("Value unbalanced transaction");
add_balance_split (trans, imbalance, root, account);
}
/* If the transaction is balanced, nothing more to do */
imbal_list = xaccTransGetImbalance (trans);
if (!imbal_list)
{
LEAVE("transaction is balanced");
return;
}
PINFO ("Currency unbalanced transaction");
for (imbalance_commod = imbal_list; imbalance_commod;
imbalance_commod = imbalance_commod->next)
{
gnc_monetary *imbal_mon = imbalance_commod->data;
gnc_commodity *commodity;
gnc_numeric old_amount, new_amount;
gnc_numeric old_value, new_value, val_imbalance;
GList *splits;
commodity = gnc_monetary_commodity (*imbal_mon);
balance_split = get_trading_split(trans, root, commodity);
if (!balance_split)
{
/* Error already logged */
gnc_monetary_list_free(imbal_list);
LEAVE("");
return;
}
account = xaccSplitGetAccount(balance_split);
if (! gnc_commodity_equal (currency, commodity))
{
/* Find the value imbalance in this commodity */
val_imbalance = gnc_numeric_zero();
for (splits = trans->splits; splits; splits = splits->next)
{
Split *split = splits->data;
if (xaccTransStillHasSplit (trans, split) &&
gnc_commodity_equal (commodity,
xaccAccountGetCommodity(xaccSplitGetAccount(split))))
val_imbalance = gnc_numeric_add (val_imbalance, xaccSplitGetValue (split),
GNC_DENOM_AUTO, GNC_HOW_DENOM_EXACT);
}
}
xaccTransBeginEdit (trans);
old_amount = xaccSplitGetAmount (balance_split);
new_amount = gnc_numeric_sub (old_amount, gnc_monetary_value(*imbal_mon),
gnc_commodity_get_fraction(commodity),
GNC_HOW_RND_ROUND_HALF_UP);
xaccSplitSetAmount (balance_split, new_amount);
if (gnc_commodity_equal (currency, commodity))
{
/* Imbalance commodity is the transaction currency, value in the
split must be the same as the amount */
xaccSplitSetValue (balance_split, new_amount);
}
else
{
old_value = xaccSplitGetValue (balance_split);
new_value = gnc_numeric_sub (old_value, val_imbalance,
gnc_commodity_get_fraction(currency),
GNC_HOW_RND_ROUND_HALF_UP);
xaccSplitSetValue (balance_split, new_value);
}
xaccSplitScrub (balance_split);
xaccTransCommitEdit (trans);
}
gnc_monetary_list_free(imbal_list);
if (!gnc_numeric_zero_p(xaccTransGetImbalanceValue(trans)))
{
/* This is probably because there are splits with zero amount
and non-zero value. These are usually realized gain/loss
splits. Add a reversing split for each of them to balance
the value. */
/* Copy the split list so we don't see the splits we're adding */
GList *splits_dup = g_list_copy(trans->splits);
for (splits = splits_dup; splits; splits = splits->next)
{
Split *split = splits->data;
if (! xaccTransStillHasSplit(trans, split)) continue;
if (!gnc_numeric_zero_p(xaccSplitGetValue(split)) &&
gnc_numeric_zero_p(xaccSplitGetAmount(split)))
{
gnc_commodity *commodity;
gnc_numeric old_value, new_value;
commodity = xaccAccountGetCommodity(xaccSplitGetAccount(split));
if (!commodity)
{
PERR("Split has no commodity");
continue;
}
balance_split = get_trading_split(trans, root, commodity);
if (!balance_split)
{
/* Error already logged */
gnc_monetary_list_free(imbal_list);
LEAVE("");
return;
}
account = xaccSplitGetAccount(balance_split);
xaccTransBeginEdit (trans);
old_value = xaccSplitGetValue (balance_split);
new_value = gnc_numeric_sub (old_value, xaccSplitGetValue(split),
gnc_commodity_get_fraction(currency),
GNC_HOW_RND_ROUND_HALF_UP);
xaccSplitSetValue (balance_split, new_value);
/* Don't change the balance split's amount since the amount
is zero in the split we're working on */
xaccSplitScrub (balance_split);
xaccTransCommitEdit (trans);
}
}
g_list_free(splits_dup);
if (!gnc_numeric_zero_p(xaccTransGetImbalanceValue(trans)))
PERR("Balancing currencies unbalanced value");
}
}
LEAVE ("()");
}
void
xaccScrubSubSplitPrice (Split *split, int maxmult, int maxamtscu)
{
gnc_numeric src_amt, src_val;
SplitList *node;
if (FALSE == is_subsplit (split)) return;
ENTER (" ");
/* Get 'price' of the indicated split */
src_amt = xaccSplitGetAmount (split);
src_val = xaccSplitGetValue (split);
/* Loop over splits, adjust each so that it has the same
* ratio (i.e. price). Change the value to get things
* right; do not change the amount */
for (node = split->parent->splits; node; node = node->next)
{
Split *s = node->data;
Transaction *txn = s->parent;
gnc_numeric dst_amt, dst_val, target_val;
gnc_numeric frac, delta;
int scu;
/* Skip the reference split */
if (s == split) continue;
scu = gnc_commodity_get_fraction (txn->common_currency);
dst_amt = xaccSplitGetAmount (s);
dst_val = xaccSplitGetValue (s);
frac = gnc_numeric_div (dst_amt, src_amt,
GNC_DENOM_AUTO, GNC_HOW_DENOM_REDUCE);
target_val = gnc_numeric_mul (frac, src_val,
scu, GNC_HOW_DENOM_EXACT | GNC_HOW_RND_ROUND_HALF_UP);
if (gnc_numeric_check (target_val))
{
PERR ("Numeric overflow of value\n"
"\tAcct=%s txn=%s\n"
"\tdst_amt=%s src_val=%s src_amt=%s\n",
xaccAccountGetName (s->acc),
xaccTransGetDescription(txn),
gnc_num_dbg_to_string(dst_amt),
gnc_num_dbg_to_string(src_val),
gnc_num_dbg_to_string(src_amt));
continue;
}
/* If the required price changes are 'small', do nothing.
* That is a case that the user will have to deal with
* manually. This routine is really intended only for
* a gross level of synchronization.
*/
delta = gnc_numeric_sub_fixed (target_val, dst_val);
delta = gnc_numeric_abs (delta);
if (maxmult * delta.num < delta.denom) continue;
/* If the amount is small, pass on that too */
if ((-maxamtscu < dst_amt.num) && (dst_amt.num < maxamtscu)) continue;
/* Make the actual adjustment */
xaccTransBeginEdit (txn);
xaccSplitSetValue (s, target_val);
xaccTransCommitEdit (txn);
}
LEAVE (" ");
}
/**
* @fixme Move this non-GUI code into the engine.
**/
static void
gnc_ui_accounts_recurse (Account *parent, GList **currency_list,
GNCSummarybarOptions options)
{
gnc_numeric start_amount;
gnc_numeric start_amount_default_currency;
gnc_numeric end_amount;
gnc_numeric end_amount_default_currency;
GNCAccountType account_type;
gnc_commodity * account_currency;
gnc_commodity * euro_commodity;
GNCCurrencyAcc *currency_accum = NULL;
GNCCurrencyAcc *euro_accum = NULL;
GNCCurrencyAcc *grand_total_accum = NULL;
GNCCurrencyAcc *non_curr_accum = NULL;
GList *children, *node;
gboolean non_currency = FALSE;
Timespec end_timespec;
Timespec start_timespec;
if (parent == NULL) return;
children = gnc_account_get_children(parent);
for (node = children; node; node = g_list_next(node))
{
Account *account = node->data;
account_type = xaccAccountGetType(account);
account_currency = xaccAccountGetCommodity(account);
if (options.grand_total)
grand_total_accum = gnc_ui_get_currency_accumulator(currency_list,
options.default_currency,
TOTAL_GRAND_TOTAL);
if (options.euro)
{
euro_commodity = gnc_get_euro ();
euro_accum = gnc_ui_get_currency_accumulator(currency_list,
euro_commodity,
TOTAL_CURR_TOTAL);
}
else
euro_commodity = NULL;
if (!gnc_commodity_is_currency(account_currency))
{
non_currency = TRUE;
non_curr_accum = gnc_ui_get_currency_accumulator(currency_list,
options.default_currency,
TOTAL_NON_CURR_TOTAL);
}
if (!non_currency || options.non_currency)
{
currency_accum = gnc_ui_get_currency_accumulator(currency_list,
account_currency,
TOTAL_SINGLE);
}
switch (account_type)
{
case ACCT_TYPE_BANK:
case ACCT_TYPE_CASH:
case ACCT_TYPE_ASSET:
case ACCT_TYPE_STOCK:
case ACCT_TYPE_MUTUAL:
case ACCT_TYPE_CREDIT:
case ACCT_TYPE_LIABILITY:
case ACCT_TYPE_PAYABLE:
case ACCT_TYPE_RECEIVABLE:
end_amount = xaccAccountGetBalanceAsOfDate(account, options.end_date);
timespecFromTime_t(&end_timespec, options.end_date);
end_amount_default_currency =
xaccAccountConvertBalanceToCurrencyAsOfDate
(account, end_amount, account_currency, options.default_currency,
timespecToTime_t(timespecCanonicalDayTime(end_timespec)));
if (!non_currency || options.non_currency)
{
currency_accum->assets =
gnc_numeric_add (currency_accum->assets, end_amount,
gnc_commodity_get_fraction (account_currency),
GNC_HOW_RND_ROUND_HALF_UP);
}
if (non_currency)
{
non_curr_accum->assets =
gnc_numeric_add (non_curr_accum->assets, end_amount_default_currency,
gnc_commodity_get_fraction (options.default_currency),
GNC_HOW_RND_ROUND_HALF_UP);
}
if (options.grand_total)
{
grand_total_accum->assets =
gnc_numeric_add (grand_total_accum->assets, end_amount_default_currency,
gnc_commodity_get_fraction (options.default_currency),
GNC_HOW_RND_ROUND_HALF_UP);
}
if (options.euro && (currency_accum != euro_accum))
{
euro_accum->assets =
gnc_numeric_add (euro_accum->assets,
gnc_convert_to_euro(account_currency, end_amount),
gnc_commodity_get_fraction (euro_commodity),
GNC_HOW_RND_ROUND_HALF_UP);
}
gnc_ui_accounts_recurse(account, currency_list, options);
break;
case ACCT_TYPE_INCOME:
case ACCT_TYPE_EXPENSE:
start_amount = xaccAccountGetBalanceAsOfDate(account, options.start_date);
timespecFromTime_t(&start_timespec, options.start_date);
start_amount_default_currency =
xaccAccountConvertBalanceToCurrencyAsOfDate
(account, start_amount, account_currency, options.default_currency,
timespecToTime_t(timespecCanonicalDayTime(start_timespec)));
end_amount = xaccAccountGetBalanceAsOfDate(account, options.end_date);
timespecFromTime_t(&end_timespec, options.end_date);
end_amount_default_currency =
xaccAccountConvertBalanceToCurrencyAsOfDate
(account, end_amount, account_currency, options.default_currency,
timespecToTime_t(timespecCanonicalDayTime(end_timespec)));
if (!non_currency || options.non_currency)
{
currency_accum->profits =
gnc_numeric_add (currency_accum->profits, start_amount,
gnc_commodity_get_fraction (account_currency),
GNC_HOW_RND_ROUND_HALF_UP);
currency_accum->profits =
gnc_numeric_sub (currency_accum->profits, end_amount,
gnc_commodity_get_fraction (account_currency),
GNC_HOW_RND_ROUND_HALF_UP);
}
if (non_currency)
{
non_curr_accum->profits =
gnc_numeric_add (non_curr_accum->profits, start_amount_default_currency,
gnc_commodity_get_fraction (options.default_currency),
GNC_HOW_RND_ROUND_HALF_UP);
non_curr_accum->profits =
gnc_numeric_sub (non_curr_accum->profits, end_amount_default_currency,
gnc_commodity_get_fraction (options.default_currency),
GNC_HOW_RND_ROUND_HALF_UP);
}
if (options.grand_total)
{
grand_total_accum->profits =
gnc_numeric_add (grand_total_accum->profits,
start_amount_default_currency,
gnc_commodity_get_fraction (options.default_currency),
GNC_HOW_RND_ROUND_HALF_UP);
grand_total_accum->profits =
gnc_numeric_sub (grand_total_accum->profits,
end_amount_default_currency,
gnc_commodity_get_fraction (options.default_currency),
GNC_HOW_RND_ROUND_HALF_UP);
}
if (options.euro && (currency_accum != euro_accum))
{
euro_accum->profits =
gnc_numeric_add (euro_accum->profits,
gnc_convert_to_euro(account_currency, start_amount),
gnc_commodity_get_fraction (euro_commodity),
GNC_HOW_RND_ROUND_HALF_UP);
euro_accum->profits =
gnc_numeric_sub (euro_accum->profits,
gnc_convert_to_euro(account_currency, end_amount),
gnc_commodity_get_fraction (euro_commodity),
GNC_HOW_RND_ROUND_HALF_UP);
}
gnc_ui_accounts_recurse(account, currency_list, options);
break;
case ACCT_TYPE_EQUITY:
/* no-op, see comments at top about summing assets */
break;
/**
* @fixme I don't know if this is right or if trading accounts should be
* treated like income and expense accounts.
**/
case ACCT_TYPE_TRADING:
break;
case ACCT_TYPE_CURRENCY:
default:
break;
}
}
g_list_free(children);
}
static CustomerWindow *
gnc_customer_new_window (QofBook *bookp, GncCustomer *cust)
{
CustomerWindow *cw;
GtkBuilder *builder;
GtkWidget *hbox, *edit;
gnc_commodity *currency;
GNCPrintAmountInfo print_info;
/*
* Find an existing window for this customer. If found, bring it to
* the front.
*/
if (cust)
{
GncGUID customer_guid;
customer_guid = *gncCustomerGetGUID(cust);
cw = gnc_find_first_gui_component (DIALOG_EDIT_CUSTOMER_CM_CLASS,
find_handler, &customer_guid);
if (cw)
{
gtk_window_present (GTK_WINDOW(cw->dialog));
return(cw);
}
}
/* Find the default currency */
if (cust)
currency = gncCustomerGetCurrency (cust);
else
currency = gnc_default_currency ();
/*
* No existing customer window found. Build a new one.
*/
cw = g_new0 (CustomerWindow, 1);
cw->book = bookp;
/* Find the dialog */
builder = gtk_builder_new();
gnc_builder_add_from_file (builder, "dialog-customer.glade", "terms_store");
gnc_builder_add_from_file (builder, "dialog-customer.glade", "tax_included_store");
gnc_builder_add_from_file (builder, "dialog-customer.glade", "taxtable_store");
gnc_builder_add_from_file (builder, "dialog-customer.glade", "Customer Dialog");
cw->dialog = GTK_WIDGET (gtk_builder_get_object (builder, "Customer Dialog"));
g_object_set_data (G_OBJECT (cw->dialog), "dialog_info", cw);
/* Get entry points */
cw->id_entry = GTK_WIDGET (gtk_builder_get_object (builder, "id_entry"));
cw->company_entry = GTK_WIDGET (gtk_builder_get_object (builder, "company_entry"));
cw->name_entry = GTK_WIDGET (gtk_builder_get_object (builder, "name_entry"));
cw->addr1_entry = GTK_WIDGET (gtk_builder_get_object (builder, "addr1_entry"));
cw->addr2_entry = GTK_WIDGET (gtk_builder_get_object (builder, "addr2_entry"));
cw->addr3_entry = GTK_WIDGET (gtk_builder_get_object (builder, "addr3_entry"));
cw->addr4_entry = GTK_WIDGET (gtk_builder_get_object (builder, "addr4_entry"));
cw->phone_entry = GTK_WIDGET (gtk_builder_get_object (builder, "phone_entry"));
cw->fax_entry = GTK_WIDGET (gtk_builder_get_object (builder, "fax_entry"));
cw->email_entry = GTK_WIDGET (gtk_builder_get_object (builder, "email_entry"));
cw->shipname_entry = GTK_WIDGET (gtk_builder_get_object (builder, "shipname_entry"));
cw->shipaddr1_entry = GTK_WIDGET (gtk_builder_get_object (builder, "shipaddr1_entry"));
cw->shipaddr2_entry = GTK_WIDGET (gtk_builder_get_object (builder, "shipaddr2_entry"));
cw->shipaddr3_entry = GTK_WIDGET (gtk_builder_get_object (builder, "shipaddr3_entry"));
cw->shipaddr4_entry = GTK_WIDGET (gtk_builder_get_object (builder, "shipaddr4_entry"));
cw->shipphone_entry = GTK_WIDGET (gtk_builder_get_object (builder, "shipphone_entry"));
cw->shipfax_entry = GTK_WIDGET (gtk_builder_get_object (builder, "shipfax_entry"));
cw->shipemail_entry = GTK_WIDGET (gtk_builder_get_object (builder, "shipemail_entry"));
cw->active_check = GTK_WIDGET (gtk_builder_get_object (builder, "active_check"));
cw->taxincluded_menu = GTK_WIDGET (gtk_builder_get_object (builder, "tax_included_menu"));
cw->notes_text = GTK_WIDGET (gtk_builder_get_object (builder, "notes_text"));
cw->terms_menu = GTK_WIDGET (gtk_builder_get_object (builder, "terms_menu"));
cw->taxtable_check = GTK_WIDGET (gtk_builder_get_object (builder, "taxtable_button"));
cw->taxtable_menu = GTK_WIDGET (gtk_builder_get_object (builder, "taxtable_menu"));
/* Currency */
edit = gnc_currency_edit_new();
gnc_currency_edit_set_currency (GNC_CURRENCY_EDIT(edit), currency);
cw->currency_edit = edit;
hbox = GTK_WIDGET (gtk_builder_get_object (builder, "currency_box"));
gtk_box_pack_start (GTK_BOX (hbox), edit, TRUE, TRUE, 0);
/* DISCOUNT: Percentage Value */
edit = gnc_amount_edit_new();
gnc_amount_edit_set_evaluate_on_enter (GNC_AMOUNT_EDIT (edit), TRUE);
print_info = gnc_integral_print_info ();
print_info.max_decimal_places = 5;
gnc_amount_edit_set_print_info (GNC_AMOUNT_EDIT (edit), print_info);
gnc_amount_edit_set_fraction (GNC_AMOUNT_EDIT (edit), 100000);
cw->discount_amount = edit;
gtk_widget_show (edit);
hbox = GTK_WIDGET (gtk_builder_get_object (builder, "discount_box"));
gtk_box_pack_start (GTK_BOX (hbox), edit, TRUE, TRUE, 0);
/* CREDIT: Monetary Value */
edit = gnc_amount_edit_new();
print_info = gnc_commodity_print_info (currency, FALSE);
gnc_amount_edit_set_evaluate_on_enter (GNC_AMOUNT_EDIT (edit), TRUE);
gnc_amount_edit_set_print_info (GNC_AMOUNT_EDIT (edit), print_info);
gnc_amount_edit_set_fraction (GNC_AMOUNT_EDIT (edit),
gnc_commodity_get_fraction (currency));
cw->credit_amount = edit;
gtk_widget_show (edit);
hbox = GTK_WIDGET (gtk_builder_get_object (builder, "credit_box"));
gtk_box_pack_start (GTK_BOX (hbox), edit, TRUE, TRUE, 0);
/* Setup signals */
gtk_builder_connect_signals_full( builder,
gnc_builder_connect_full_func,
cw);
/* Setup initial values */
if (cust != NULL)
{
GtkTextBuffer* text_buffer;
GncAddress *addr, *shipaddr;
const char *string;
cw->dialog_type = EDIT_CUSTOMER;
cw->customer_guid = *gncCustomerGetGUID (cust);
addr = gncCustomerGetAddr (cust);
shipaddr = gncCustomerGetShipAddr (cust);
gtk_entry_set_text (GTK_ENTRY (cw->id_entry), gncCustomerGetID (cust));
gtk_entry_set_text (GTK_ENTRY (cw->company_entry), gncCustomerGetName (cust));
/* Setup Address */
gtk_entry_set_text (GTK_ENTRY (cw->name_entry), gncAddressGetName (addr));
gtk_entry_set_text (GTK_ENTRY (cw->addr1_entry), gncAddressGetAddr1 (addr));
gtk_entry_set_text (GTK_ENTRY (cw->addr2_entry), gncAddressGetAddr2 (addr));
gtk_entry_set_text (GTK_ENTRY (cw->addr3_entry), gncAddressGetAddr3 (addr));
gtk_entry_set_text (GTK_ENTRY (cw->addr4_entry), gncAddressGetAddr4 (addr));
gtk_entry_set_text (GTK_ENTRY (cw->phone_entry), gncAddressGetPhone (addr));
gtk_entry_set_text (GTK_ENTRY (cw->fax_entry), gncAddressGetFax (addr));
gtk_entry_set_text (GTK_ENTRY (cw->email_entry), gncAddressGetEmail (addr));
/* Setup Ship-to Address */
gtk_entry_set_text (GTK_ENTRY (cw->shipname_entry), gncAddressGetName (shipaddr));
gtk_entry_set_text (GTK_ENTRY (cw->shipaddr1_entry), gncAddressGetAddr1 (shipaddr));
gtk_entry_set_text (GTK_ENTRY (cw->shipaddr2_entry), gncAddressGetAddr2 (shipaddr));
gtk_entry_set_text (GTK_ENTRY (cw->shipaddr3_entry), gncAddressGetAddr3 (shipaddr));
gtk_entry_set_text (GTK_ENTRY (cw->shipaddr4_entry), gncAddressGetAddr4 (shipaddr));
gtk_entry_set_text (GTK_ENTRY (cw->shipphone_entry), gncAddressGetPhone (shipaddr));
gtk_entry_set_text (GTK_ENTRY (cw->shipfax_entry), gncAddressGetFax (shipaddr));
gtk_entry_set_text (GTK_ENTRY (cw->shipemail_entry), gncAddressGetEmail (shipaddr));
/* Set toggle buttons */
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (cw->active_check),
gncCustomerGetActive (cust));
string = gncCustomerGetNotes (cust);
text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW(cw->notes_text));
gtk_text_buffer_set_text (text_buffer, string, -1);
cw->component_id =
gnc_register_gui_component (DIALOG_EDIT_CUSTOMER_CM_CLASS,
gnc_customer_window_refresh_handler,
gnc_customer_window_close_handler,
cw);
cw->terms = gncCustomerGetTerms (cust);
}
else
{
cust = gncCustomerCreate (bookp);
cw->customer_guid = *gncCustomerGetGUID (cust);
cw->dialog_type = NEW_CUSTOMER;
cw->component_id =
gnc_register_gui_component (DIALOG_NEW_CUSTOMER_CM_CLASS,
gnc_customer_window_refresh_handler,
gnc_customer_window_close_handler,
cw);
/* XXX: get the global-default terms */
cw->terms = NULL;
}
/* I know that cust exists here -- either passed in or just created */
cw->taxincluded = gncCustomerGetTaxIncluded (cust);
gnc_taxincluded_combo (GTK_COMBO_BOX(cw->taxincluded_menu), cw->taxincluded);
gnc_billterms_combo (GTK_COMBO_BOX(cw->terms_menu), bookp, TRUE, cw->terms);
cw->taxtable = gncCustomerGetTaxTable (cust);
gnc_taxtables_combo (GTK_COMBO_BOX(cw->taxtable_menu), bookp, TRUE, cw->taxtable);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (cw->taxtable_check),
gncCustomerGetTaxTableOverride (cust));
gnc_customer_taxtable_check_cb (GTK_TOGGLE_BUTTON (cw->taxtable_check), cw);
/* Set up the addr line quickfill */
cw->addr2_quickfill = gnc_get_shared_address_addr2_quickfill(cw->book, ADDR_QUICKFILL);
cw->addr3_quickfill = gnc_get_shared_address_addr3_quickfill(cw->book, ADDR_QUICKFILL);
cw->addr4_quickfill = gnc_get_shared_address_addr4_quickfill(cw->book, ADDR_QUICKFILL);
/* Set the Discount, and Credit amounts */
gnc_amount_edit_set_amount (GNC_AMOUNT_EDIT (cw->discount_amount),
gncCustomerGetDiscount (cust));
gnc_amount_edit_set_amount (GNC_AMOUNT_EDIT (cw->credit_amount),
gncCustomerGetCredit (cust));
gnc_gui_component_watch_entity_type (cw->component_id,
GNC_CUSTOMER_MODULE_NAME,
QOF_EVENT_MODIFY | QOF_EVENT_DESTROY);
gtk_widget_show_all (cw->dialog);
g_object_unref(G_OBJECT(builder));
return cw;
}
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(" ");
}
/* Either sets the value and amount for split and returns TRUE, or
does nothing and returns FALSE. */
static gboolean
gtu_sr_handle_exchange_rate (GncTreeViewSplitReg *view, gnc_numeric amount, Transaction *trans, Split *split, gboolean force)
{
GncTreeModelSplitReg *model;
XferDialog *xfer;
gboolean rate_split_ok, rate_reg_ok;
gnc_numeric rate_split, rate_reg, value;
Account *reg_acc;
gnc_commodity *xfer_comm = xaccAccountGetCommodity (xaccSplitGetAccount (split));
gnc_commodity *reg_comm = gnc_tree_view_split_reg_get_reg_commodity (view);
gnc_commodity *trans_curr = xaccTransGetCurrency (trans);
gboolean expanded;
gboolean have_rate = TRUE;
ENTER("handle_exchange_rate amount %s, trans %p and split %p force %d", gnc_numeric_to_string (amount), trans, split, force);
model = gnc_tree_view_split_reg_get_model_from_view (view);
reg_acc = gnc_tree_model_split_reg_get_anchor (model);
/* Rate from trans-curr to split-comm */
rate_split_ok = xaccTransGetRateForCommodity (trans, xfer_comm, split, &rate_split);
DEBUG("rate_split_ok %d and xfer_comm %s", rate_split_ok, gnc_commodity_get_fullname (xfer_comm));
/* Rate from trans-curr to reg-comm */
rate_reg_ok = xaccTransGetRateForCommodity (trans, reg_comm, split, &rate_reg);
DEBUG("rate_reg_ok %d and reg_comm %s", rate_reg_ok, gnc_commodity_get_fullname (reg_comm));
/* Are we expanded */
expanded = gnc_tree_view_split_reg_trans_expanded (view, trans);
if (gnc_commodity_equal (trans_curr, xfer_comm) && rate_split_ok)
{
xaccSplitSetAmount (split, amount);
xaccSplitSetValue (split, amount);
return TRUE;
}
if (rate_reg_ok && rate_split_ok && !force)
{
value = gnc_numeric_div (amount, rate_reg, gnc_commodity_get_fraction (trans_curr), GNC_HOW_DENOM_REDUCE);
amount = gnc_numeric_mul (value, rate_split, GNC_DENOM_AUTO, GNC_HOW_RND_ROUND);
}
else
{
if (!rate_split_ok)
rate_split = gtu_sr_get_rate_from_db (reg_comm, xfer_comm);
/* create the exchange-rate dialog */
xfer = gnc_xfer_dialog (NULL, NULL);
gnc_xfer_dialog_is_exchange_dialog (xfer, &rate_split);
/* fill in the dialog entries */
gnc_xfer_dialog_set_description (xfer, xaccTransGetDescription (trans));
gnc_xfer_dialog_set_memo (xfer, xaccSplitGetMemo (split));
/* Get per book option */
gnc_xfer_dialog_set_num (xfer, gnc_get_num_action (trans, split));
gnc_xfer_dialog_set_date (xfer, timespecToTime64 (xaccTransRetDatePostedTS (trans)));
value = amount;
if (gnc_xfer_dialog_run_exchange_dialog (xfer, &rate_split, value, reg_acc, trans, xfer_comm, expanded))
{
if (!rate_split_ok)
rate_split = gnc_numeric_create (1, 1);
have_rate = FALSE;
}
else
have_rate = TRUE;
amount = gnc_numeric_mul (value, rate_split, GNC_DENOM_AUTO, GNC_HOW_RND_ROUND);
}
xaccSplitSetAmount (split, amount);
xaccSplitSetValue (split, value);
LEAVE("handle_exchange_rate set split %p amt=%s; and val=%s", split, gnc_numeric_to_string (amount), gnc_numeric_to_string (value));
return have_rate;
}
