static gint
sort_ns_or_cm (GtkTreeModel *f_model,
GtkTreeIter *f_iter_a,
GtkTreeIter *f_iter_b)
{
GncTreeModelPrice *model;
GtkTreeModel *tree_model;
GtkTreeIter iter_a, iter_b;
gnc_commodity_namespace *ns_a, *ns_b;
gnc_commodity *comm_a, *comm_b;
tree_model = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(f_model));
model = GNC_TREE_MODEL_PRICE(tree_model);
gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER(f_model),
&iter_a,
f_iter_a);
gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER(f_model),
&iter_b,
f_iter_b);
if (gnc_tree_model_price_iter_is_namespace (model, &iter_a))
{
ns_a = gnc_tree_model_price_get_namespace (model, &iter_a);
ns_b = gnc_tree_model_price_get_namespace (model, &iter_b);
return safe_utf8_collate (gnc_commodity_namespace_get_name (ns_a),
gnc_commodity_namespace_get_name (ns_b));
}
comm_a = gnc_tree_model_price_get_commodity (model, &iter_a);
comm_b = gnc_tree_model_price_get_commodity (model, &iter_b);
return safe_utf8_collate (gnc_commodity_get_mnemonic (comm_a),
gnc_commodity_get_mnemonic (comm_b));
}
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;
}
static gint
default_sort (GNCPrice *price_a, GNCPrice *price_b)
{
gnc_commodity *curr_a, *curr_b;
Timespec ts_a, ts_b;
gint result;
/* Primary sort (i.e. commodity name) handled by the tree structure. */
/* secondary sort: currency */
curr_a = gnc_price_get_currency (price_a);
curr_b = gnc_price_get_currency (price_b);
result = safe_utf8_collate (gnc_commodity_get_namespace (curr_a),
gnc_commodity_get_namespace (curr_b));
if (result != 0) return result;
result = safe_utf8_collate (gnc_commodity_get_mnemonic (curr_a),
gnc_commodity_get_mnemonic (curr_b));
if (result != 0) return result;
/* tertiary sort: time */
ts_a = gnc_price_get_time (price_a);
ts_b = gnc_price_get_time (price_b);
result = timespec_cmp (&ts_a, &ts_b);
if (result)
/* Reverse the result to present the most recent quote first. */
return -result;
/* last sort: value */
return gnc_numeric_compare (gnc_price_get_value (price_a),
gnc_price_get_value (price_b));
}
static void
move_quote_source (Account *account, gpointer data)
{
gnc_commodity *com;
gnc_quote_source *quote_source;
gboolean new_style = GPOINTER_TO_INT(data);
const char *source, *tz;
com = xaccAccountGetCommodity(account);
if (!com)
return;
if (!new_style)
{
source = dxaccAccountGetPriceSrc(account);
if (!source || !*source)
return;
tz = dxaccAccountGetQuoteTZ(account);
PINFO("to %8s from %s", gnc_commodity_get_mnemonic(com),
xaccAccountGetName(account));
gnc_commodity_set_quote_flag(com, TRUE);
quote_source = gnc_quote_source_lookup_by_internal(source);
if (!quote_source)
quote_source = gnc_quote_source_add_new(source, FALSE);
gnc_commodity_set_quote_source(com, quote_source);
gnc_commodity_set_quote_tz(com, tz);
}
dxaccAccountSetPriceSrc(account, NULL);
dxaccAccountSetQuoteTZ(account, NULL);
return;
}
/*
* Retrieve the selected commodity from an commodity tree view. The
* commodity tree must be in single selection mode.
*/
gnc_commodity *
gnc_tree_view_commodity_get_selected_commodity (GncTreeViewCommodity *view)
{
GtkTreeSelection *selection;
GtkTreeModel *model, *f_model, *s_model;
GtkTreeIter iter, f_iter, s_iter;
gnc_commodity *commodity;
g_return_val_if_fail (GNC_IS_TREE_VIEW_COMMODITY (view), NULL);
ENTER("view %p", view);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(view));
if (!gtk_tree_selection_get_selected (selection, &s_model, &s_iter))
{
LEAVE("no commodity, get_selected failed");
return FALSE;
}
gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (s_model),
&f_iter, &s_iter);
f_model = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(s_model));
gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (f_model),
&iter, &f_iter);
model = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(f_model));
commodity = gnc_tree_model_commodity_get_commodity (GNC_TREE_MODEL_COMMODITY(model),
&iter);
LEAVE("commodity %p (%s)", commodity,
commodity ? gnc_commodity_get_mnemonic(commodity) : "");
return commodity;
}
static void
gnc_currency_edit_mnemonic_changed (GObject *gobject,
GParamSpec *pspec,
gpointer user_data)
{
GNCCurrencyEdit *self = GNC_CURRENCY_EDIT (gobject);
GNCCurrencyEditPrivate *priv = GET_PRIVATE (self);
gnc_commodity *currency = gnc_commodity_table_lookup (gnc_get_current_commodities (),
GNC_COMMODITY_NS_CURRENCY,
priv->mnemonic);
/* If there isn't any such commodity, get the default */
if (!currency)
{
currency = gnc_locale_default_currency();
DEBUG("gce %p, default currency mnemonic %s",
self, gnc_commodity_get_mnemonic(currency));
}
g_signal_handlers_block_by_func(G_OBJECT(self),
G_CALLBACK(gnc_currency_edit_mnemonic_changed), user_data);
gnc_currency_edit_set_currency(self, currency);
g_signal_handlers_unblock_by_func(G_OBJECT(self),
G_CALLBACK(gnc_currency_edit_mnemonic_changed), user_data);
}
static void
TransScrubOrphansFast (Transaction *trans, Account *root)
{
GList *node;
gchar *accname;
if (!trans) return;
g_return_if_fail (root);
for (node = trans->splits; node; node = node->next)
{
Split *split = node->data;
Account *orph;
if (split->acc) continue;
DEBUG ("Found an orphan \n");
accname = g_strconcat (_("Orphan"), "-",
gnc_commodity_get_mnemonic (trans->common_currency),
NULL);
orph = xaccScrubUtilityGetOrMakeAccount (root, trans->common_currency,
accname, ACCT_TYPE_BANK, FALSE);
g_free (accname);
if (!orph) continue;
xaccSplitSetAccount(split, orph);
}
}
/************************************************************/
#define debug_path(fn, path) { \
gchar *path_string = gtk_tree_path_to_string(path); \
fn("tree path %s", path_string); \
g_free(path_string); \
}
#if 0 /* Not Used */
static gboolean
gnc_tree_view_commodity_get_iter_from_commodity (GncTreeViewCommodity *view,
gnc_commodity *commodity,
GtkTreeIter *s_iter)
{
GtkTreeModel *model, *f_model, *s_model;
GtkTreeIter iter, f_iter;
g_return_val_if_fail(GNC_IS_TREE_VIEW_COMMODITY(view), FALSE);
g_return_val_if_fail(commodity != NULL, FALSE);
g_return_val_if_fail(s_iter != NULL, FALSE);
ENTER("view %p, commodity %p (%s)", view, commodity, gnc_commodity_get_mnemonic(commodity));
/* Reach down to the real model and get an iter for this commodity */
s_model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
f_model = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(s_model));
model = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(f_model));
if (!gnc_tree_model_commodity_get_iter_from_commodity (GNC_TREE_MODEL_COMMODITY(model), commodity, &iter))
{
LEAVE("model_get_iter_from_commodity failed");
return FALSE;
}
/* convert back to a sort iter */
gtk_tree_model_filter_convert_child_iter_to_iter (GTK_TREE_MODEL_FILTER(f_model),
&f_iter, &iter);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT(s_model),
s_iter, &f_iter);
LEAVE(" ");
return TRUE;
}
static gboolean
test_add_account (const char* tag, gpointer globaldata, gpointer data)
{
Account* account = static_cast<decltype (account)> (data);
act_data* gdata = (act_data*)globaldata;
gnc_commodity* com;
gnc_commodity* new_com;
gnc_commodity_table* t;
com = xaccAccountGetCommodity (account);
t = gnc_commodity_table_get_table (sixbook);
new_com = gnc_commodity_table_lookup (t,
gnc_commodity_get_namespace (com),
gnc_commodity_get_mnemonic (com));
if (new_com)
{
xaccAccountSetCommodity (account, new_com);
}
do_test_args (xaccAccountEqual ((Account*)account, (Account*) (gdata->act),
TRUE),
"gnc_account_sixtp_parser_create",
__FILE__, __LINE__, "%d", gdata->value);
return TRUE;
}
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;
}
// Commodity Mnemonic
static gchar*
add_comm_mnemonic (gchar *so_far, Transaction *trans, Split *split, CsvExportInfo *info)
{
const gchar *comm_m;
gchar *conv;
gchar *result;
if (split == NULL)
comm_m = gnc_commodity_get_mnemonic (xaccTransGetCurrency (trans));
else
comm_m = gnc_commodity_get_mnemonic (xaccAccountGetCommodity (xaccSplitGetAccount(split)));
conv = csv_txn_test_field_string (info, comm_m);
result = g_strconcat (so_far, conv, info->mid_sep, NULL);
g_free (conv);
g_free (so_far);
return result;
}
static gint
sort_by_value (GtkTreeModel *f_model,
GtkTreeIter *f_iter_a,
GtkTreeIter *f_iter_b,
gpointer user_data)
{
gnc_commodity *comm_a, *comm_b;
GNCPrice *price_a, *price_b;
gboolean result;
gint value;
if (!get_prices (f_model, f_iter_a, f_iter_b, &price_a, &price_b))
return sort_ns_or_cm (f_model, f_iter_a, f_iter_b);
/*
* Sorted by commodity because of the tree structure. Now sort by
* currency so we're only comparing numbers in the same currency
* denomination.
*/
comm_a = gnc_price_get_currency (price_a);
comm_b = gnc_price_get_currency (price_b);
if (comm_a && comm_b)
{
value = safe_utf8_collate (gnc_commodity_get_namespace (comm_a),
gnc_commodity_get_namespace (comm_b));
if (value != 0)
return value;
value = safe_utf8_collate (gnc_commodity_get_mnemonic (comm_a),
gnc_commodity_get_mnemonic (comm_b));
if (value != 0)
return value;
}
/*
* Now do the actual price comparison now we're sure that its an
* apples to apples comparison.
*/
result = gnc_numeric_compare (gnc_price_get_value (price_a),
gnc_price_get_value (price_b));
if (result)
return result;
return default_sort (price_a, price_b);
}
xmlNodePtr
commodity_ref_to_dom_tree(const char *tag, const gnc_commodity *c)
{
xmlNodePtr ret;
g_return_val_if_fail(c, NULL);
ret = xmlNewNode(NULL, BAD_CAST tag);
if (!gnc_commodity_get_namespace(c) || !gnc_commodity_get_mnemonic(c))
{
return NULL;
}
xmlNewTextChild(ret, NULL, BAD_CAST "cmdty:space", BAD_CAST gnc_commodity_get_namespace_compat(c));
xmlNewTextChild(ret, NULL, BAD_CAST "cmdty:id", BAD_CAST gnc_commodity_get_mnemonic(c));
return ret;
}
static int
gnc_euro_rate_compare (const void * key, const void * value)
{
const gnc_commodity * curr = key;
const gnc_euro_rate_struct * euro = value;
if (!key || !value)
return -1;
return g_ascii_strcasecmp(gnc_commodity_get_mnemonic(curr), euro->currency);
}
static void gnc_currency_edit_active_changed (GtkComboBox *gobject,
gpointer user_data)
{
GNCCurrencyEdit *self = GNC_CURRENCY_EDIT (gobject);
gnc_commodity *currency = gnc_currency_edit_get_currency (self);
const gchar *mnemonic = gnc_commodity_get_mnemonic (currency);
g_signal_handlers_block_by_func(G_OBJECT(self),
G_CALLBACK(gnc_currency_edit_active_changed), user_data);
g_object_set (G_OBJECT (self), "mnemonic", mnemonic, NULL);
g_signal_handlers_unblock_by_func(G_OBJECT(self),
G_CALLBACK(gnc_currency_edit_active_changed), user_data);
}
static void
gtvo_update_column_names (GncTreeView *view)
{
GncTreeViewOwnerPrivate *priv;
const gchar *mnemonic;
priv = GNC_TREE_VIEW_OWNER_GET_PRIVATE(view);
mnemonic = gnc_commodity_get_mnemonic(gnc_default_report_currency());
gtvo_update_column_name(priv->balance_report_column,
/* Translators: %s is a currency mnemonic.*/
_("Balance (%s)"), mnemonic);
gnc_tree_view_set_show_column_menu(view, FALSE);
gnc_tree_view_set_show_column_menu(view, TRUE);
}
xmlNodePtr
commodity_ref_to_dom_tree(const char *tag, const gnc_commodity *c)
{
xmlNodePtr ret;
gchar *name_space, *mnemonic;
g_return_val_if_fail(c, NULL);
ret = xmlNewNode(NULL, BAD_CAST tag);
if (!gnc_commodity_get_namespace(c) || !gnc_commodity_get_mnemonic(c))
{
return NULL;
}
name_space = g_strdup (gnc_commodity_get_namespace_compat(c));
mnemonic = g_strdup (gnc_commodity_get_mnemonic(c));
xmlNewTextChild(ret, NULL, BAD_CAST "cmdty:space",
checked_char_cast (name_space));
xmlNewTextChild(ret, NULL, BAD_CAST "cmdty:id",
checked_char_cast (mnemonic));
g_free (name_space);
g_free (mnemonic);
return ret;
}
static Split *
get_balance_split (Transaction *trans, Account *root, Account *account,
gnc_commodity *commodity)
{
Split *balance_split;
gchar *accname;
if (!account ||
!gnc_commodity_equiv (commodity, xaccAccountGetCommodity(account)))
{
if (!root)
{
root = gnc_book_get_root_account (xaccTransGetBook (trans));
if (NULL == root)
{
/* This can't occur, things should be in books */
PERR ("Bad data corruption, no root account in book");
return NULL;
}
}
accname = g_strconcat (_("Imbalance"), "-",
gnc_commodity_get_mnemonic (commodity), NULL);
account = xaccScrubUtilityGetOrMakeAccount (root, commodity,
accname, ACCT_TYPE_BANK, FALSE);
g_free (accname);
if (!account)
{
PERR ("Can't get balancing account");
return NULL;
}
}
balance_split = xaccTransFindSplitByAccount(trans, account);
/* Put split into account before setting split value */
if (!balance_split)
{
balance_split = xaccMallocSplit (qof_instance_get_book(trans));
xaccTransBeginEdit (trans);
xaccSplitSetParent(balance_split, trans);
xaccSplitSetAccount(balance_split, account);
xaccTransCommitEdit (trans);
}
return balance_split;
}
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;
}
/* Find the trading split for a commodity, but don't create any splits
or accounts if they don't already exist. */
static Split *
find_trading_split (Transaction *trans, Account *root,
gnc_commodity *commodity)
{
Account *trading_account;
Account *ns_account;
Account *account;
if (!root)
{
root = gnc_book_get_root_account (xaccTransGetBook (trans));
if (NULL == root)
{
/* This can't occur, things should be in books */
PERR ("Bad data corruption, no root account in book");
return NULL;
}
}
trading_account = gnc_account_lookup_by_name (root, _("Trading"));
if (!trading_account)
{
return NULL;
}
ns_account = gnc_account_lookup_by_name (trading_account,
gnc_commodity_get_namespace(commodity));
if (!ns_account)
{
return NULL;
}
account = gnc_account_lookup_by_name (ns_account,
gnc_commodity_get_mnemonic(commodity));
if (!account)
{
return NULL;
}
return xaccTransFindSplitByAccount(trans, account);
}
/*******************************************************
* csv_tree_export
*
* write a list of accounts settings to a text file
*******************************************************/
void csv_tree_export (CsvExportInfo *info)
{
FILE *fh;
Account *root;
Account *acc;
GList *accts, *ptr;
ENTER("");
DEBUG("File name is : %s", info->file_name);
/* Get list of Accounts */
root = gnc_book_get_root_account (gnc_get_current_book());
accts = gnc_account_get_descendants_sorted (root);
info->failed = FALSE;
/* Open File for writing */
fh = g_fopen (info->file_name, "w");
if (fh != NULL)
{
gchar *header;
gchar *part1;
gchar *part2;
const gchar *currentSel;
gchar *end_sep;
gchar *mid_sep;
int i;
/* Set up separators */
if (info->use_quotes)
{
end_sep = "\"";
mid_sep = g_strconcat ("\"", info->separator_str, "\"", NULL);
}
else
{
end_sep = "";
mid_sep = g_strconcat (info->separator_str, NULL);
}
/* Header string, 'eol = end of line marker' */
header = g_strconcat (end_sep, _("type"), mid_sep, _("full_name"), mid_sep, _("name"), mid_sep,
_("code"), mid_sep, _("description"), mid_sep, _("color"), mid_sep,
_("notes"), mid_sep, _("commoditym"), mid_sep, _("commodityn"), mid_sep,
_("hidden"), mid_sep, _("tax"), mid_sep, _("place_holder"), end_sep, EOLSTR, NULL);
DEBUG("Header String: %s", header);
/* Write header line */
if (!write_line_to_file (fh, header))
{
info->failed = TRUE;
g_free (mid_sep);
g_free (header);
return;
}
g_free (header);
/* Go through list of accounts */
for (ptr = accts, i = 0; ptr; ptr = g_list_next (ptr), i++)
{
gchar *fullname = NULL;
gchar *str_temp = NULL;
acc = ptr->data;
DEBUG("Account being processed is : %s", xaccAccountGetName (acc));
/* Type */
currentSel = xaccAccountTypeEnumAsString (xaccAccountGetType (acc));
part1 = g_strconcat (end_sep, currentSel, mid_sep, NULL);
/* Full Name */
fullname = gnc_account_get_full_name (acc);
str_temp = csv_test_field_string (info, fullname);
part2 = g_strconcat (part1, str_temp, mid_sep, NULL);
g_free (str_temp);
g_free (fullname);
g_free (part1);
/* Name */
currentSel = xaccAccountGetName (acc);
str_temp = csv_test_field_string (info, currentSel);
part1 = g_strconcat (part2, str_temp, mid_sep, NULL);
g_free (str_temp);
g_free (part2);
/* Code */
currentSel = xaccAccountGetCode (acc) ? xaccAccountGetCode (acc) : "";
str_temp = csv_test_field_string (info, currentSel);
part2 = g_strconcat (part1, str_temp, mid_sep, NULL);
g_free (str_temp);
g_free (part1);
/* Description */
currentSel = xaccAccountGetDescription (acc) ? xaccAccountGetDescription (acc) : "";
str_temp = csv_test_field_string (info, currentSel);
part1 = g_strconcat (part2, str_temp, mid_sep, NULL);
g_free (str_temp);
g_free (part2);
/* Color */
currentSel = xaccAccountGetColor (acc) ? xaccAccountGetColor (acc) : "" ;
str_temp = csv_test_field_string (info, currentSel);
part2 = g_strconcat (part1, str_temp, mid_sep, NULL);
g_free (str_temp);
g_free (part1);
/* Notes */
currentSel = xaccAccountGetNotes (acc) ? xaccAccountGetNotes (acc) : "" ;
str_temp = csv_test_field_string (info, currentSel);
part1 = g_strconcat (part2, str_temp, mid_sep, NULL);
g_free (str_temp);
g_free (part2);
/* Commodity Mnemonic */
currentSel = gnc_commodity_get_mnemonic (xaccAccountGetCommodity (acc));
str_temp = csv_test_field_string (info, currentSel);
part2 = g_strconcat (part1, str_temp, mid_sep, NULL);
g_free (str_temp);
g_free (part1);
/* Commodity Namespace */
currentSel = gnc_commodity_get_namespace (xaccAccountGetCommodity (acc));
str_temp = csv_test_field_string (info, currentSel);
part1 = g_strconcat (part2, str_temp, mid_sep, NULL);
g_free (str_temp);
g_free (part2);
/* Hidden */
currentSel = xaccAccountGetHidden (acc) ? "T" : "F" ;
part2 = g_strconcat (part1, currentSel, mid_sep, NULL);
g_free (part1);
/* Tax */
currentSel = xaccAccountGetTaxRelated (acc) ? "T" : "F" ;
part1 = g_strconcat (part2, currentSel, mid_sep, NULL);
g_free (part2);
/* Place Holder / end of line marker */
currentSel = xaccAccountGetPlaceholder (acc) ? "T" : "F" ;
part2 = g_strconcat (part1, currentSel, end_sep, EOLSTR, NULL);
g_free (part1);
DEBUG("Account String: %s", part2);
/* Write to file */
if (!write_line_to_file (fh, part2))
{
info->failed = TRUE;
break;
}
g_free (part2);
}
g_free (mid_sep);
}
else
info->failed = TRUE;
if (fh)
fclose (fh);
g_list_free (accts);
LEAVE("");
}
/* Get the trading split for a given commodity, creating it (and the
necessary accounts) if it doesn't exist. */
static Split *
get_trading_split (Transaction *trans, Account *root,
gnc_commodity *commodity)
{
Split *balance_split;
Account *trading_account;
Account *ns_account;
Account *account;
gnc_commodity *default_currency = NULL;
if (!root)
{
root = gnc_book_get_root_account (xaccTransGetBook (trans));
if (NULL == root)
{
/* This can't occur, things should be in books */
PERR ("Bad data corruption, no root account in book");
return NULL;
}
}
/* Get the default currency. This is harder than it seems. It's not
possible to call gnc_default_currency() since it's a UI function. One
might think that the currency of the root account would do, but the root
account has no currency. Instead look for the Income placeholder account
and use its currency. */
default_currency = xaccAccountGetCommodity(gnc_account_lookup_by_name(root,
_("Income")));
if (! default_currency)
{
default_currency = commodity;
}
trading_account = xaccScrubUtilityGetOrMakeAccount (root,
default_currency,
_("Trading"),
ACCT_TYPE_TRADING, TRUE);
if (!trading_account)
{
PERR ("Can't get trading account");
return NULL;
}
ns_account = xaccScrubUtilityGetOrMakeAccount (trading_account,
default_currency,
gnc_commodity_get_namespace(commodity),
ACCT_TYPE_TRADING, TRUE);
if (!ns_account)
{
PERR ("Can't get namespace account");
return NULL;
}
account = xaccScrubUtilityGetOrMakeAccount (ns_account, commodity,
gnc_commodity_get_mnemonic(commodity),
ACCT_TYPE_TRADING, FALSE);
if (!account)
{
PERR ("Can't get commodity account");
return NULL;
}
balance_split = xaccTransFindSplitByAccount(trans, account);
/* Put split into account before setting split value */
if (!balance_split)
{
balance_split = xaccMallocSplit (qof_instance_get_book(trans));
xaccTransBeginEdit (trans);
xaccSplitSetParent(balance_split, trans);
xaccSplitSetAccount(balance_split, account);
xaccTransCommitEdit (trans);
}
return balance_split;
}
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 const char*
node_and_commodity_equal (xmlNodePtr node, const gnc_commodity* com)
{
xmlNodePtr mark;
while (g_strcmp0 ((char*)node->name, "text") == 0)
node = node->next;
if (!check_dom_tree_version (node, "2.0.0"))
{
return "version wrong. Not 2.0.0 or not there";
}
if (!node->name || g_strcmp0 ((char*)node->name, "gnc:commodity"))
{
return "Name of toplevel node is bad";
}
for (mark = node->xmlChildrenNode; mark; mark = mark->next)
{
if (g_strcmp0 ((char*)mark->name, "text") == 0)
{
}
else if (g_strcmp0 ((char*)mark->name, "cmdty:space") == 0)
{
if (!equals_node_val_vs_string (
mark, gnc_commodity_get_namespace_compat (com)))
{
return "namespaces differ";
}
}
else if (g_strcmp0 ((char*)mark->name, "cmdty:id") == 0)
{
if (!equals_node_val_vs_string (
mark, gnc_commodity_get_mnemonic (com)))
{
return "mnemonic differ";
}
}
else if (g_strcmp0 ((char*)mark->name, "cmdty:name") == 0)
{
if (!equals_node_val_vs_string (
mark, gnc_commodity_get_fullname (com)))
{
return "names differ";
}
}
else if (g_strcmp0 ((char*)mark->name, "cmdty:xcode") == 0)
{
if (!equals_node_val_vs_string (
mark, gnc_commodity_get_cusip (com)))
{
return "exchange codes differ";
}
}
else if (g_strcmp0 ((char*)mark->name, "cmdty:fraction") == 0)
{
gchar* txt;
gint64 type;
txt = dom_tree_to_text (mark);
if (!txt)
{
return "couldn't get fraction string";
}
else if (!string_to_gint64 (txt, &type))
{
g_free (txt);
return "couldn't convert fraction string to int";
}
else if (type != gnc_commodity_get_fraction (com))
{
g_free (txt);
return "fractions differ";
}
else
{
g_free (txt);
}
}
else if (g_strcmp0 ((char*)mark->name, "cmdty:slots") == 0)
{
if (!equals_node_val_vs_kvp_frame (mark,
gnc_commodity_get_kvp_frame (com)))
return "slots differ";
}
/* Legitimate tags which we don't yet have tests */
else if (g_strcmp0 ((char*)mark->name, "cmdty:get_quotes") == 0 ||
g_strcmp0 ((char*)mark->name, "cmdty:quote_source") == 0 ||
g_strcmp0 ((char*)mark->name, "cmdty:quote_tz") == 0)
{
continue;
}
else
{
return "unknown node";
}
}
return NULL;
}
static
void
gsr2_redraw_all_cb (GncTreeViewSplitReg *view, gpointer user_data)
{
GNCSplitReg2 *gsr = user_data;
gnc_commodity * commodity;
GNCPrintAmountInfo print_info;
gnc_numeric amount = gnc_numeric_zero();
Account *leader;
gboolean reverse;
gboolean euro;
if ( gsr->summarybar == NULL )
return;
leader = gnc_ledger_display2_leader( gsr->ledger );
commodity = xaccAccountGetCommodity( leader );
/* no EURO converson, if account is already EURO or no EURO currency */
if (commodity != NULL)
euro = (gnc_is_euro_currency( commodity ) &&
(strncasecmp(gnc_commodity_get_mnemonic(commodity), "EUR", 3)));
else
euro = FALSE;
print_info = gnc_account_print_info( leader, TRUE );
reverse = gnc_reverse_balance( leader );
gsr2_update_summary_label( gsr->balance_label,
xaccAccountGetPresentBalance,
leader, print_info, commodity, reverse, euro );
gsr2_update_summary_label( gsr->cleared_label,
xaccAccountGetClearedBalance,
leader, print_info, commodity, reverse, euro );
gsr2_update_summary_label( gsr->reconciled_label,
xaccAccountGetReconciledBalance,
leader, print_info, commodity, reverse, euro );
gsr2_update_summary_label( gsr->future_label,
xaccAccountGetBalance,
leader, print_info, commodity, reverse, euro );
gsr2_update_summary_label( gsr->projectedminimum_label,
xaccAccountGetProjectedMinimumBalance,
leader, print_info, commodity, reverse, euro );
/* Print the summary share amount */
if (gsr->shares_label != NULL)
{
char string[256];
print_info = gnc_account_print_info( leader, TRUE );
amount = xaccAccountGetBalance( leader );
if ( reverse )
amount = gnc_numeric_neg( amount );
xaccSPrintAmount( string, amount, print_info );
gnc_set_label_color( gsr->shares_label, amount );
gtk_label_set_text( GTK_LABEL(gsr->shares_label), string );
}
/* Print the summary share value */
if (gsr->value_label != NULL)
{
char string[256];
gnc_commodity *currency = gnc_default_currency ();
print_info = gnc_commodity_print_info (currency, TRUE);
xaccSPrintAmount (string, amount, print_info);
gnc_set_label_color (gsr->value_label, amount);
gtk_label_set_text (GTK_LABEL (gsr->value_label), string);
}
}
void
xaccTransScrubCurrency (Transaction *trans)
{
SplitList *node;
gnc_commodity *currency;
if (!trans) return;
/* If there are any orphaned splits in a transaction, then the
* this routine will fail. Therefore, we want to make sure that
* there are no orphans (splits without parent account).
*/
xaccTransScrubOrphans (trans);
currency = xaccTransGetCurrency (trans);
if (currency && gnc_commodity_is_currency(currency)) return;
currency = xaccTransFindCommonCurrency (trans, qof_instance_get_book(trans));
if (currency)
{
xaccTransBeginEdit (trans);
xaccTransSetCurrency (trans, currency);
xaccTransCommitEdit (trans);
}
else
{
if (NULL == trans->splits)
{
PWARN ("Transaction \"%s\" has no splits in it!", trans->description);
}
else
{
SplitList *node;
char guid_str[GUID_ENCODING_LENGTH + 1];
guid_to_string_buff(xaccTransGetGUID(trans), guid_str);
PWARN ("no common transaction currency found for trans=\"%s\" (%s);",
trans->description, guid_str);
for (node = trans->splits; node; node = node->next)
{
Split *split = node->data;
if (NULL == split->acc)
{
PWARN (" split=\"%s\" is not in any account!", split->memo);
}
else
{
gnc_commodity *currency = xaccAccountGetCommodity(split->acc);
PWARN ("setting to split=\"%s\" account=\"%s\" commodity=\"%s\"",
split->memo, xaccAccountGetName(split->acc),
gnc_commodity_get_mnemonic(currency));
xaccTransBeginEdit (trans);
xaccTransSetCurrency (trans, currency);
xaccTransCommitEdit (trans);
return;
}
}
}
return;
}
for (node = trans->splits; node; node = node->next)
{
Split *sp = node->data;
if (!gnc_numeric_equal(xaccSplitGetAmount (sp),
xaccSplitGetValue (sp)))
{
gnc_commodity *acc_currency;
acc_currency = sp->acc ? xaccAccountGetCommodity(sp->acc) : NULL;
if (acc_currency == currency)
{
/* This Split needs fixing: The transaction-currency equals
* the account-currency/commodity, but the amount/values are
* inequal i.e. they still correspond to the security
* (amount) and the currency (value). In the new model, the
* value is the amount in the account-commodity -- so it
* needs to be set to equal the amount (since the
* account-currency doesn't exist anymore).
*
* Note: Nevertheless we lose some information here. Namely,
* the information that the 'amount' in 'account-old-security'
* was worth 'value' in 'account-old-currency'. Maybe it would
* be better to store that information in the price database?
* But then, for old currency transactions there is still the
* 'other' transaction, which is going to keep that
* information. So I don't bother with that here. -- cstim,
* 2002/11/20. */
PWARN ("Adjusted split with mismatched values, desc=\"%s\" memo=\"%s\""
" old amount %s %s, new amount %s",
trans->description, sp->memo,
gnc_num_dbg_to_string (xaccSplitGetAmount(sp)),
gnc_commodity_get_mnemonic (currency),
gnc_num_dbg_to_string (xaccSplitGetValue(sp)));
xaccTransBeginEdit (trans);
xaccSplitSetAmount (sp, xaccSplitGetValue(sp));
xaccTransCommitEdit (trans);
}
/*else
{
PINFO ("Ok: Split '%s' Amount %s %s, value %s %s",
xaccSplitGetMemo (sp),
gnc_num_dbg_to_string (amount),
gnc_commodity_get_mnemonic (currency),
gnc_num_dbg_to_string (value),
gnc_commodity_get_mnemonic (acc_currency));
}*/
}
}
}
static gint
_get_vars_helper(Transaction *txn, void *var_hash_data)
{
GHashTable *var_hash = (GHashTable*)var_hash_data;
GList *split_list;
kvp_frame *kvpf;
kvp_value *kvp_val;
Split *s;
char *str;
gnc_commodity *first_cmdty = NULL;
split_list = xaccTransGetSplitList(txn);
if (split_list == NULL)
{
return 1;
}
for ( ; split_list; split_list = split_list->next)
{
gnc_commodity *split_cmdty = NULL;
GncGUID *acct_guid;
Account *acct;
s = (Split*)split_list->data;
kvpf = xaccSplitGetSlots(s);
kvp_val = kvp_frame_get_slot_path(kvpf,
GNC_SX_ID,
GNC_SX_ACCOUNT,
NULL);
acct_guid = kvp_value_get_guid(kvp_val);
acct = xaccAccountLookup(acct_guid, gnc_get_current_book());
split_cmdty = xaccAccountGetCommodity(acct);
if (first_cmdty == NULL)
{
first_cmdty = split_cmdty;
}
if (! gnc_commodity_equal(split_cmdty, first_cmdty))
{
GncSxVariable *var;
GString *var_name;
const gchar *split_mnemonic, *first_mnemonic;
var_name = g_string_sized_new(16);
split_mnemonic = gnc_commodity_get_mnemonic(split_cmdty);
first_mnemonic = gnc_commodity_get_mnemonic(first_cmdty);
g_string_printf(var_name, "%s -> %s",
split_mnemonic ? split_mnemonic : "(null)",
first_mnemonic ? first_mnemonic : "(null)");
var = gnc_sx_variable_new(g_strdup(var_name->str));
g_hash_table_insert(var_hash, g_strdup(var->name), var);
g_string_free(var_name, TRUE);
}
// existing... ------------------------------------------
kvp_val = kvp_frame_get_slot_path(kvpf,
GNC_SX_ID,
GNC_SX_CREDIT_FORMULA,
NULL);
if (kvp_val != NULL)
{
str = kvp_value_get_string(kvp_val);
if (str && strlen(str) != 0)
{
gnc_sx_parse_vars_from_formula(str, var_hash, NULL);
}
}
kvp_val = kvp_frame_get_slot_path(kvpf,
GNC_SX_ID,
GNC_SX_DEBIT_FORMULA,
NULL);
if (kvp_val != NULL)
{
str = kvp_value_get_string(kvp_val);
if (str && strlen(str) != 0)
{
gnc_sx_parse_vars_from_formula(str, var_hash, NULL);
}
}
}
return 0;
}
static int
fill_account_list (StockSplitInfo *info, Account *selected_account)
{
GtkTreeRowReference *reference = NULL;
GtkTreeView *view;
GtkListStore *list;
GtkTreeIter iter;
GtkTreePath *path;
GList *accounts;
GList *node;
gint rows = 0;
gchar *full_name;
view = GTK_TREE_VIEW(info->account_view);
list = GTK_LIST_STORE(gtk_tree_view_get_model(view));
gtk_list_store_clear (list);
accounts = gnc_account_get_descendants_sorted (gnc_get_current_root_account ());
for (node = accounts; node; node = node->next)
{
Account *account = node->data;
GNCPrintAmountInfo print_info;
const gnc_commodity *commodity;
gnc_numeric balance;
if (!xaccAccountIsPriced(account))
continue;
balance = xaccAccountGetBalance (account);
if (gnc_numeric_zero_p (balance))
continue;
if (xaccAccountGetPlaceholder (account))
continue;
commodity = xaccAccountGetCommodity (account);
full_name = gnc_account_get_full_name (account);
print_info = gnc_account_print_info (account, FALSE);
gtk_list_store_append(list, &iter);
gtk_list_store_set(list, &iter,
SPLIT_COL_ACCOUNT, account,
SPLIT_COL_FULLNAME, full_name,
SPLIT_COL_MNEMONIC, gnc_commodity_get_mnemonic(commodity),
SPLIT_COL_SHARES, xaccPrintAmount(balance, print_info),
-1);
if (account == selected_account)
{
path = gtk_tree_model_get_path(GTK_TREE_MODEL(list), &iter);
reference = gtk_tree_row_reference_new(GTK_TREE_MODEL(list), path);
gtk_tree_path_free(path);
}
g_free (full_name);
rows++;
}
g_list_free(accounts);
if (reference)
{
GtkTreeSelection* selection = gtk_tree_view_get_selection(view);
path = gtk_tree_row_reference_get_path(reference);
gtk_tree_row_reference_free(reference);
if (path)
{
gtk_tree_selection_select_path(selection, path);
gtk_tree_view_scroll_to_cell(view, path, NULL, TRUE, 0.5, 0.0);
gtk_tree_path_free(path);
}
}
return rows;
}
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);
}