static AB_ACCOUNT *
update_account_list_acc_cb(AB_ACCOUNT *ab_acc, gpointer user_data)
{
ABInitialInfo *info = user_data;
gchar *gnc_name, *ab_name;
Account *gnc_acc;
GtkTreeIter iter;
g_return_val_if_fail(ab_acc && info, NULL);
ab_name = ab_account_longname(ab_acc);
/* Get corresponding gnucash account */
gnc_acc = g_hash_table_lookup(info->gnc_hash, ab_acc);
/* Build the text for the gnucash account. */
if (gnc_acc)
gnc_name = gnc_account_get_full_name(gnc_acc);
else
gnc_name = g_strdup("");
/* Add item to the list store */
gtk_list_store_append(info->account_store, &iter);
gtk_list_store_set(info->account_store, &iter,
ACCOUNT_LIST_COL_AB_NAME, ab_name,
ACCOUNT_LIST_COL_AB_ACCT, ab_acc,
ACCOUNT_LIST_COL_GNC_NAME, gnc_name,
ACCOUNT_LIST_COL_CHECKED, FALSE,
-1);
g_free(gnc_name);
g_free(ab_name);
return NULL;
}
// Account Name short or Long
static gchar*
add_account_name (gchar *so_far, Account *acc, Split *split, gboolean full, CsvExportInfo *info)
{
gchar *name = NULL;
gchar *conv;
gchar *result;
Account *account = NULL;
if (split == NULL)
{
if (acc == NULL)
name = g_strdup (" ");
else
account = acc;
}
else
account = xaccSplitGetAccount (split);
if (account != NULL)
{
if (full)
name = gnc_account_get_full_name (account);
else
name = g_strdup (xaccAccountGetName (account));
}
conv = csv_txn_test_field_string (info, name);
result = g_strconcat (so_far, conv, info->mid_sep, NULL);
g_free (name);
g_free (conv);
g_free (so_far);
return result;
}
static void
placeholder_cell_data_func (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell,
GtkTreeModel *model,
GtkTreeIter *iter,
gpointer user_data)
{
Account *account, *root;
gboolean willbe_placeholder = FALSE;
GncAccountMergeDisposition disp;
g_return_if_fail (GTK_TREE_MODEL (model));
account = gnc_tree_view_account_get_account_from_iter (model, iter);
root = gnc_book_get_root_account(gnc_get_current_book());
disp = determine_merge_disposition(root, account);
switch (disp)
{
case GNC_ACCOUNT_MERGE_DISPOSITION_USE_EXISTING:
{
/* find the existing account, do whatever it is. */
gchar *full_name;
Account *existing_acct;
full_name = gnc_account_get_full_name(account);
existing_acct = gnc_account_lookup_by_full_name(root, full_name);
willbe_placeholder = xaccAccountGetPlaceholder(existing_acct);
g_free(full_name);
}
break;
case GNC_ACCOUNT_MERGE_DISPOSITION_CREATE_NEW:
willbe_placeholder = xaccAccountGetPlaceholder(account);
break;
}
gtk_cell_renderer_toggle_set_active(GTK_CELL_RENDERER_TOGGLE(cell), willbe_placeholder);
}
void gnc_ui_payment_window_set_postaccount (PaymentWindow *pw, const Account* account)
{
g_assert(pw);
g_assert(account);
{
gchar *acct_string = gnc_account_get_full_name (account);
gnc_cbwe_set_by_string(GTK_COMBO_BOX(pw->post_combo), acct_string);
g_free(acct_string);
}
}
int gncTaxTableEntryCompare (const GncTaxTableEntry *a, const GncTaxTableEntry *b)
{
char *name_a, *name_b;
int retval;
if (!a && !b) return 0;
if (!a) return -1;
if (!b) return 1;
name_a = gnc_account_get_full_name (a->account);
name_b = gnc_account_get_full_name (b->account);
retval = g_strcmp0(name_a, name_b);
g_free(name_a);
g_free(name_b);
if (retval)
return retval;
return gnc_numeric_compare (a->amount, b->amount);
}
GncAccountMergeDisposition
determine_merge_disposition(Account *existing_root, Account *new_acct)
{
Account *existing_acct;
gchar *full_name;
full_name = gnc_account_get_full_name(new_acct);
existing_acct = gnc_account_lookup_by_full_name(existing_root, full_name);
g_free(full_name);
return determine_account_merge_disposition(existing_acct, new_acct);
}
static char *
gnc_autoclear_make_window_name(Account *account)
{
char *fullname;
char *title;
fullname = gnc_account_get_full_name(account);
title = g_strconcat(fullname, " - ", _("Auto-clear"), NULL);
g_free(fullname);
return title;
}
static void
get_account_info (FindAccountDialog *facc_dialog)
{
Account *root;
GList *accts;
GList *ptr;
gchar *filter_text;
gboolean radio_root;
/* Get the state of the root radio button */
radio_root = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(facc_dialog->radio_root));
/* Get list of Accounts */
if ((facc_dialog->account == NULL) || (radio_root == TRUE))
root = gnc_book_get_root_account (gnc_get_current_book());
else
root = facc_dialog->account;
accts = gnc_account_get_descendants_sorted (root);
filter_text = g_ascii_strdown (gtk_entry_get_text (GTK_ENTRY(facc_dialog->filter_text_entry)), -1);
/* Go through list of accounts */
for (ptr = accts; ptr; ptr = g_list_next (ptr))
{
Account *acc = ptr->data;
gchar *full_name = gnc_account_get_full_name (acc);
gchar *match_string = g_ascii_strdown (full_name, -1);
if ((g_strcmp0 (filter_text, "") == 0) || (g_strrstr (match_string, filter_text) != NULL))
fill_model (facc_dialog, acc);
g_free (match_string);
g_free (full_name);
}
g_free (filter_text);
g_list_free (accts);
gtk_tree_view_columns_autosize (GTK_TREE_VIEW(facc_dialog->view));
}
/**************************************************
* gnc_csv_account_map_load_mappings
*
* load the existing mappings
**************************************************/
void
gnc_csv_account_map_load_mappings (GtkTreeModel *mappings_store)
{
GtkTreeIter iter;
gboolean valid;
// Set iter to first entry of store
valid = gtk_tree_model_get_iter_first (mappings_store, &iter);
// Walk through the store trying to match to a map
while (valid)
{
Account *account = NULL;
gchar *map_string;
gchar *fullpath;
// Walk through the list, reading each row
gtk_tree_model_get (GTK_TREE_MODEL(mappings_store), &iter, MAPPING_STRING, &map_string, MAPPING_ACCOUNT, &account, -1);
if (account == NULL) // if account is NULL, store has not been updated
{
account = gnc_csv_account_map_search (map_string); //search the account list for the map_string
if (account == NULL) // account still NULL, we have no map
{
g_free (map_string);
valid = gtk_tree_model_iter_next (mappings_store, &iter);
continue;
}
}
fullpath = gnc_account_get_full_name (account);
gtk_list_store_set (GTK_LIST_STORE(mappings_store), &iter, MAPPING_FULLPATH, fullpath, -1);
gtk_list_store_set (GTK_LIST_STORE(mappings_store), &iter, MAPPING_ACCOUNT, account, -1);
g_free (fullpath);
g_free (map_string);
valid = gtk_tree_model_iter_next (mappings_store, &iter);
}
}
static void
fill_model (FindAccountDialog *facc_dialog, Account *account)
{
GtkTreeModel *model;
GtkTreeIter iter;
gchar *fullname = gnc_account_get_full_name (account);
gint splits = xaccAccountCountSplits (account, TRUE);
gnc_numeric total = xaccAccountGetBalanceInCurrency (account, NULL, TRUE);
PINFO("Add to Store: Account '%s'", fullname);
model = gtk_tree_view_get_model (GTK_TREE_VIEW(facc_dialog->view));
gtk_list_store_append (GTK_LIST_STORE(model), &iter);
gtk_list_store_set (GTK_LIST_STORE(model), &iter,
ACC_FULL_NAME, fullname, ACCOUNT, account,
PLACE_HOLDER, (xaccAccountGetPlaceholder (account) == TRUE ? GTK_STOCK_YES : NULL),
HIDDEN, (xaccAccountGetHidden (account) == TRUE ? GTK_STOCK_YES : NULL),
NOT_USED, (splits == 0 ? GTK_STOCK_YES : NULL),
BAL_ZERO, (gnc_numeric_zero_p (total) == TRUE ? GTK_STOCK_YES : NULL), -1);
g_free (fullname);
}
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
tax_table_entries_refresh (TaxTableWindow *ttw)
{
GList *list, *node;
GtkTreeView *view;
GtkListStore *store;
GtkTreeIter iter;
GtkTreePath *path;
GtkTreeSelection *selection;
GtkTreeRowReference *reference = NULL;
GncTaxTableEntry *selected_entry;
g_return_if_fail (ttw);
view = GTK_TREE_VIEW (ttw->entries_view);
store = GTK_LIST_STORE(gtk_tree_view_get_model(view));
/* Clear the list */
selected_entry = ttw->current_entry;
gtk_list_store_clear (store);
if (ttw->current_table == NULL)
return;
/* Add the items to the list */
list = gncTaxTableGetEntries (ttw->current_table);
if (list)
list = g_list_reverse (g_list_copy (list));
for (node = list ; node; node = node->next)
{
char *row_text[3];
GncTaxTableEntry *entry = node->data;
Account *acc = gncTaxTableEntryGetAccount (entry);
gnc_numeric amount = gncTaxTableEntryGetAmount (entry);
row_text[0] = gnc_account_get_full_name (acc);
switch (gncTaxTableEntryGetType (entry))
{
case GNC_AMT_TYPE_PERCENT:
row_text[1] =
g_strdup_printf ("%s%%",
xaccPrintAmount (amount,
gnc_default_print_info (FALSE)));
break;
default:
row_text[1] =
g_strdup_printf ("%s",
xaccPrintAmount (amount,
gnc_default_print_info (TRUE)));
break;
}
gtk_list_store_prepend(store, &iter);
gtk_list_store_set(store, &iter,
TAX_ENTRY_COL_NAME, row_text[0],
TAX_ENTRY_COL_POINTER, entry,
TAX_ENTRY_COL_AMOUNT, row_text[1],
-1);
if (entry == selected_entry)
{
path = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &iter);
reference = gtk_tree_row_reference_new(GTK_TREE_MODEL(store), path);
gtk_tree_path_free(path);
}
g_free (row_text[0]);
g_free (row_text[1]);
}
if (reference)
{
path = gtk_tree_row_reference_get_path(reference);
gtk_tree_row_reference_free(reference);
if (path)
{
selection = gtk_tree_view_get_selection(view);
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);
}
}
}
/*******************************************************
* 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("");
}
Account *
gnc_account_select_combo_fill (GtkWidget *combo, QofBook *book,
GList *acct_types, GList *acct_commodities)
{
GtkListStore *store;
GtkTreeIter iter;
GList *list, *node;
const gchar *text;
g_return_val_if_fail (combo && GTK_IS_COMBO_BOX(combo), NULL);
g_return_val_if_fail (book, NULL);
g_return_val_if_fail (acct_types, NULL);
/* Figure out if anything is set in the combo */
text = gtk_entry_get_text(GTK_ENTRY (gtk_bin_get_child(GTK_BIN (GTK_COMBO_BOX(combo)))));
g_object_set_data (G_OBJECT(combo), "book", book);
list = gnc_account_get_descendants (gnc_book_get_root_account (book));
/* Clear the existing list */
store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(combo)));
gtk_list_store_clear(store);
/* Add the account names to the combo box */
for (node = list; node; node = node->next)
{
Account *account = node->data;
char *name;
/* Only present accounts of the appropriate type */
if (g_list_index (acct_types, (gpointer)xaccAccountGetType (account))
== -1)
continue;
/* Only present accounts with the right commodity, if that's a
restriction */
if (acct_commodities)
{
if ( g_list_find_custom( acct_commodities,
GINT_TO_POINTER(xaccAccountGetCommodity(account)),
gnc_commodity_compare_void) == NULL )
{
continue;
}
}
name = gnc_account_get_full_name (account);
gtk_list_store_append(store, &iter);
gtk_list_store_set (store, &iter, 0, name, -1);
/* Save the first account name in case no account name was set */
if (!text || g_strcmp0 (text, "") == 0)
{
text = g_strdup (name);
}
g_free(name);
}
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 0);
g_list_free (list);
gnc_cbwe_set_by_string(GTK_COMBO_BOX(combo), text);
return gnc_account_select_combo_get_active (combo);
}
static void
gnc_find_account_dialog_create (GtkWidget *parent, FindAccountDialog *facc_dialog)
{
GtkWidget *dialog;
GtkBuilder *builder;
GtkTreeSelection *selection;
GtkTreeViewColumn *tree_column;
GtkCellRenderer *cr;
ENTER(" ");
builder = gtk_builder_new();
gnc_builder_add_from_file (builder, "dialog-find-account.glade", "list-store");
gnc_builder_add_from_file (builder, "dialog-find-account.glade", "Find Account Dialog");
dialog = GTK_WIDGET(gtk_builder_get_object (builder, "Find Account Dialog"));
facc_dialog->dialog = dialog;
facc_dialog->session = gnc_get_current_session();
/* parent */
if (parent != NULL)
{
facc_dialog->parent = parent;
gtk_window_set_transient_for (GTK_WINDOW(dialog), GTK_WINDOW(parent));
}
else
facc_dialog->parent = NULL;
/* Connect the radio buttons...*/
facc_dialog->radio_root = GTK_WIDGET(gtk_builder_get_object (builder, "radio-root"));
facc_dialog->radio_subroot = GTK_WIDGET(gtk_builder_get_object (builder, "radio-subroot"));
facc_dialog->filter_text_entry = GTK_WIDGET(gtk_builder_get_object (builder, "filter-text-entry"));
facc_dialog->sub_label = GTK_WIDGET(gtk_builder_get_object (builder, "sub-label"));
facc_dialog->radio_hbox = GTK_WIDGET(gtk_builder_get_object (builder, "hbox-radio"));
facc_dialog->filter_button = GTK_WIDGET(gtk_builder_get_object (builder, "filter-button"));
g_signal_connect (facc_dialog->filter_button, "clicked",
G_CALLBACK(filter_button_cb), (gpointer)facc_dialog);
facc_dialog->view = GTK_WIDGET(gtk_builder_get_object (builder, "treeview"));
g_signal_connect (facc_dialog->view, "row-activated",
G_CALLBACK(row_double_clicked), (gpointer)facc_dialog);
/* Enable alternative line colors */
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW(facc_dialog->view), TRUE);
/* default to 'close' button */
gtk_dialog_set_default_response (GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(facc_dialog->view));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
/* Need to add pixbuf renderers here to get the xalign to work. */
tree_column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title (tree_column, _("Place Holder"));
gtk_tree_view_append_column (GTK_TREE_VIEW(facc_dialog->view), tree_column);
gtk_tree_view_column_set_alignment (tree_column, 0.5);
gtk_tree_view_column_set_expand (tree_column, TRUE);
cr = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start (tree_column, cr, TRUE);
// connect 'active' and set 'xalign' property of the cell renderer
gtk_tree_view_column_set_attributes (tree_column, cr, "stock-id", PLACE_HOLDER, NULL);
gtk_cell_renderer_set_alignment (cr, 0.5, 0.5);
tree_column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title (tree_column, _("Hidden"));
gtk_tree_view_append_column (GTK_TREE_VIEW(facc_dialog->view), tree_column);
gtk_tree_view_column_set_alignment (tree_column, 0.5);
gtk_tree_view_column_set_expand (tree_column, TRUE);
cr = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start (tree_column, cr, TRUE);
// connect 'active' and set 'xalign' property of the cell renderer
gtk_tree_view_column_set_attributes (tree_column, cr, "stock-id", HIDDEN, NULL);
gtk_cell_renderer_set_alignment (cr, 0.5, 0.5);
tree_column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title (tree_column, _("Not Used"));
gtk_tree_view_append_column (GTK_TREE_VIEW(facc_dialog->view), tree_column);
gtk_tree_view_column_set_alignment (tree_column, 0.5);
gtk_tree_view_column_set_expand (tree_column, TRUE);
cr = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start (tree_column, cr, TRUE);
// connect 'active' and set 'xalign' property of the cell renderer
gtk_tree_view_column_set_attributes (tree_column, cr, "stock-id", NOT_USED, NULL);
gtk_cell_renderer_set_alignment (cr, 0.5, 0.5);
tree_column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title (tree_column, _("Balance Zero"));
gtk_tree_view_append_column (GTK_TREE_VIEW(facc_dialog->view), tree_column);
gtk_tree_view_column_set_alignment (tree_column, 0.5);
gtk_tree_view_column_set_expand (tree_column, TRUE);
cr = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start (tree_column, cr, TRUE);
// connect 'active' and set 'xalign' property of the cell renderer
gtk_tree_view_column_set_attributes (tree_column, cr, "stock-id", BAL_ZERO, NULL);
gtk_cell_renderer_set_alignment (cr, 0.5, 0.5);
gtk_builder_connect_signals_full (builder, gnc_builder_connect_full_func, facc_dialog);
g_object_unref (G_OBJECT(builder));
gnc_restore_window_size (GNC_PREFS_GROUP, GTK_WINDOW(facc_dialog->dialog));
if (facc_dialog->account != NULL)
{
const gchar *sub_label_start = _("Search from ");
gchar *sub_full_name = gnc_account_get_full_name (facc_dialog->account);
gchar *sub_label;
sub_label = g_strconcat (sub_label_start, sub_full_name, NULL);
gtk_button_set_label (GTK_BUTTON(facc_dialog->radio_subroot), sub_label);
g_free (sub_full_name);
g_free (sub_label);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(facc_dialog->radio_subroot), TRUE);
gtk_widget_show_all (facc_dialog->radio_hbox);
}
else
gtk_widget_hide_all (facc_dialog->radio_hbox);
// Set the filter to Wildcard
gtk_entry_set_text (GTK_ENTRY(facc_dialog->filter_text_entry), "");
get_account_info (facc_dialog);
LEAVE(" ");
}
static PaymentWindow *
new_payment_window (GncOwner *owner, QofBook *book, GncInvoice *invoice)
{
PaymentWindow *pw;
GtkBuilder *builder;
GtkWidget *box, *label, *credit_box, *debit_box;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
char * cm_class = (gncOwnerGetType (owner) == GNC_OWNER_CUSTOMER ?
DIALOG_PAYMENT_CUSTOMER_CM_CLASS :
DIALOG_PAYMENT_VENDOR_CM_CLASS);
/*
* Find an existing payment window. If found, bring it to
* the front. If we have an actual owner, then set it in
* the window.
*/
pw = gnc_find_first_gui_component (cm_class, find_handler, NULL);
if (pw)
{
if (gncOwnerIsValid(owner))
gnc_payment_set_owner (pw, owner);
// Reset the setting about the pre-existing TXN
pw->pre_existing_txn = NULL;
gtk_window_present (GTK_WINDOW(pw->dialog));
return(pw);
}
/* Ok, we need a new window */
pw = g_new0 (PaymentWindow, 1);
pw->book = book;
gncOwnerCopy (owner, &(pw->owner));
/* Compute the post-to account types */
pw->acct_types = gncOwnerGetAccountTypesList (owner);
if (gncOwnerIsValid(owner))
pw->acct_commodities = gncOwnerGetCommoditiesList (owner);
/* Open and read the Glade File */
builder = gtk_builder_new();
gnc_builder_add_from_file (builder, "dialog-payment.glade", "docs_list_hor_adj");
gnc_builder_add_from_file (builder, "dialog-payment.glade", "docs_list_vert_adj");
gnc_builder_add_from_file (builder, "dialog-payment.glade", "docs_list_model");
gnc_builder_add_from_file (builder, "dialog-payment.glade", "post_combo_model");
gnc_builder_add_from_file (builder, "dialog-payment.glade", "Payment Dialog");
pw->dialog = GTK_WIDGET (gtk_builder_get_object (builder, "Payment Dialog"));
/* Grab the widgets and build the dialog */
pw->payment_warning = GTK_WIDGET (gtk_builder_get_object (builder, "payment_warning"));
pw->ok_button = GTK_WIDGET (gtk_builder_get_object (builder, "okbutton"));
pw->num_entry = GTK_WIDGET (gtk_builder_get_object (builder, "num_entry"));
pw->memo_entry = GTK_WIDGET (gtk_builder_get_object (builder, "memo_entry"));
pw->post_combo = GTK_WIDGET (gtk_builder_get_object (builder, "post_combo"));
gtk_combo_box_set_entry_text_column( GTK_COMBO_BOX( pw->post_combo ), 0 );
gnc_cbwe_require_list_item(GTK_COMBO_BOX(pw->post_combo));
label = GTK_WIDGET (gtk_builder_get_object (builder, "owner_label"));
box = GTK_WIDGET (gtk_builder_get_object (builder, "owner_box"));
pw->owner_choice = gnc_owner_select_create (label, box, book, owner);
/* Some terminology:
* Invoices are paid, credit notes are refunded.
* A customer payment is a credit action, paying a vendor is debit
*
* So depending on the owner the payment amount should be considered
* credit (customer) or debit (vendor/employee) and refunds should be
* considered debit (customer) or credit (vendor/employee).
* For visual consistency, the dialog box will always show a payment and
* a refund field. Internally they are treated as credit or debit depending
* on the owner type.
*/
if (gncOwnerGetType (owner) == GNC_OWNER_CUSTOMER)
{
debit_box = GTK_WIDGET (gtk_builder_get_object (builder, "amount_refund_box"));
credit_box = GTK_WIDGET (gtk_builder_get_object (builder, "amount_payment_box"));
}
else
{
debit_box = GTK_WIDGET (gtk_builder_get_object (builder, "amount_payment_box"));
credit_box = GTK_WIDGET (gtk_builder_get_object (builder, "amount_refund_box"));
}
pw->amount_debit_edit = gnc_amount_edit_new ();
gtk_box_pack_start (GTK_BOX (debit_box), pw->amount_debit_edit, TRUE, TRUE, 0);
gnc_amount_edit_set_evaluate_on_enter (GNC_AMOUNT_EDIT (pw->amount_debit_edit),
TRUE);
gnc_amount_edit_set_amount (GNC_AMOUNT_EDIT (pw->amount_debit_edit), gnc_numeric_zero());
g_signal_connect(G_OBJECT(gnc_amount_edit_gtk_entry(GNC_AMOUNT_EDIT(pw->amount_debit_edit))),
"focus-out-event",
G_CALLBACK(gnc_payment_leave_amount_cb), pw);
pw->amount_credit_edit = gnc_amount_edit_new ();
gtk_box_pack_start (GTK_BOX (credit_box), pw->amount_credit_edit, TRUE, TRUE, 0);
gnc_amount_edit_set_evaluate_on_enter (GNC_AMOUNT_EDIT (pw->amount_credit_edit),
TRUE);
gnc_amount_edit_set_amount (GNC_AMOUNT_EDIT (pw->amount_credit_edit), gnc_numeric_zero());
g_signal_connect(G_OBJECT(gnc_amount_edit_gtk_entry(GNC_AMOUNT_EDIT(pw->amount_credit_edit))),
"focus-out-event",
G_CALLBACK(gnc_payment_leave_amount_cb), pw);
box = GTK_WIDGET (gtk_builder_get_object (builder, "date_box"));
pw->date_edit = gnc_date_edit_new (time(NULL), FALSE, FALSE);
gtk_box_pack_start (GTK_BOX (box), pw->date_edit, TRUE, TRUE, 0);
pw->docs_list_tree_view = GTK_WIDGET (gtk_builder_get_object (builder, "docs_list_tree_view"));
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(pw->docs_list_tree_view));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
/* Configure date column */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_get_column (GTK_TREE_VIEW (pw->docs_list_tree_view), 0);
gtk_tree_view_column_pack_start (column, renderer, TRUE);
tree_view_column_set_default_width (GTK_TREE_VIEW (pw->docs_list_tree_view),
column, "31-12-2013");
gtk_tree_view_column_set_cell_data_func (column, renderer,
(GtkTreeCellDataFunc) print_date,
NULL, NULL);
/* Configure document number column */
column = gtk_tree_view_get_column (GTK_TREE_VIEW (pw->docs_list_tree_view), 1);
tree_view_column_set_default_width (GTK_TREE_VIEW (pw->docs_list_tree_view),
column, "INV2013-016");
/* Configure document type column */
column = gtk_tree_view_get_column (GTK_TREE_VIEW (pw->docs_list_tree_view), 2);
tree_view_column_set_default_width (GTK_TREE_VIEW (pw->docs_list_tree_view),
column, _("Credit Note"));
/* Configure debit column */
column = gtk_tree_view_get_column (GTK_TREE_VIEW (pw->docs_list_tree_view), 3);
tree_view_column_set_default_width (GTK_TREE_VIEW (pw->docs_list_tree_view),
column, "11,999.00");
/* Configure credit column */
column = gtk_tree_view_get_column (GTK_TREE_VIEW (pw->docs_list_tree_view), 4);
tree_view_column_set_default_width (GTK_TREE_VIEW (pw->docs_list_tree_view),
column, "11,999.00");
gtk_tree_sortable_set_sort_column_id (
GTK_TREE_SORTABLE (gtk_tree_view_get_model (GTK_TREE_VIEW (pw->docs_list_tree_view))),
0, GTK_SORT_ASCENDING);
box = GTK_WIDGET (gtk_builder_get_object (builder, "acct_window"));
pw->acct_tree = GTK_WIDGET(gnc_tree_view_account_new (FALSE));
gtk_container_add (GTK_CONTAINER (box), pw->acct_tree);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(pw->acct_tree), FALSE);
gnc_payment_set_account_types (GNC_TREE_VIEW_ACCOUNT (pw->acct_tree));
/* Set the dialog for the 'new' owner.
* Note that this also sets the post account tree. */
gnc_payment_dialog_owner_changed(pw);
/* Set the dialog for the 'new' invoice */
pw->invoice = invoice;
if (invoice)
{
Account *postacct = gncInvoiceGetPostedAcc (invoice);
if (postacct)
{
gchar *acct_string = gnc_account_get_full_name (postacct);
gnc_cbwe_set_by_string(GTK_COMBO_BOX(pw->post_combo), acct_string);
gnc_payment_dialog_post_to_changed_cb (pw->post_combo, pw);
g_free(acct_string);
}
}
/* Setup signals */
gtk_builder_connect_signals_full( builder,
gnc_builder_connect_full_func,
pw);
g_signal_connect (G_OBJECT (pw->owner_choice), "changed",
G_CALLBACK (gnc_payment_dialog_owner_changed_cb), pw);
g_signal_connect (G_OBJECT (pw->acct_tree), "row-activated",
G_CALLBACK (gnc_payment_acct_tree_row_activated_cb), pw);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(pw->acct_tree));
g_signal_connect (G_OBJECT (selection), "changed",
G_CALLBACK (gnc_payment_dialog_xfer_acct_changed_cb), pw);
/* Register with the component manager */
pw->component_id =
gnc_register_gui_component (cm_class,
gnc_payment_window_refresh_handler,
gnc_payment_window_close_handler,
pw);
/* Watch for any new or changed accounts */
gnc_gui_component_watch_entity_type (pw->component_id,
GNC_ID_ACCOUNT,
QOF_EVENT_CREATE | QOF_EVENT_MODIFY |
QOF_EVENT_DESTROY);
/* Show it all */
gtk_widget_show_all (pw->dialog);
g_object_unref(G_OBJECT(builder));
// The customer choice widget should have keyboard focus
if (GNC_IS_GENERAL_SEARCH(pw->owner_choice))
{
gnc_general_search_grab_focus(GNC_GENERAL_SEARCH(pw->owner_choice));
}
/* Reflect if the payment could complete now */
gnc_payment_window_check_payment (pw);
/* Warn the user if they have no valid post-to accounts */
{
const gchar *text;
const char *acct_type;
text = gtk_entry_get_text(GTK_ENTRY (gtk_bin_get_child(GTK_BIN (GTK_COMBO_BOX(pw->post_combo)))));
if (!text || g_strcmp0 (text, "") == 0)
{
/* The code below assumes there will only be one account type.
* Let's assert this to protect from potential future changes. */
g_assert (g_list_length (pw->acct_types) == 1);
acct_type = xaccAccountGetTypeStr(GPOINTER_TO_INT(pw->acct_types->data));
gnc_warning_dialog(pw->dialog,
_("You have no valid \"Post To\" accounts. "
"Please create an account of type \"%s\" "
"before you continue to process this payment. "
"Perhaps you want to create an Invoice or "
"Bill first?"),
acct_type);
}
}
return pw;
}
static void
account_list_changed_cb(GtkTreeSelection *selection, gpointer user_data)
{
ABInitialInfo *info = user_data;
GtkTreeModel *model;
GtkTreeIter iter;
AB_ACCOUNT *ab_acc;
gchar *longname, *gnc_name;
Account *old_value, *gnc_acc;
const gchar *currency;
gnc_commodity *commodity = NULL;
gboolean ok_pressed;
g_return_if_fail(info);
if (!gtk_tree_selection_get_selected(selection, &model, &iter))
return;
gtk_tree_model_get(model, &iter, ACCOUNT_LIST_COL_AB_ACCT, &ab_acc, -1);
/* Avoid recursion when unselecting the item again */
g_signal_handlers_block_by_func(selection, account_list_changed_cb, info);
gtk_tree_selection_unselect_iter(selection, &iter);
g_signal_handlers_unblock_by_func(selection, account_list_changed_cb, info);
if (ab_acc)
{
old_value = g_hash_table_lookup(info->gnc_hash, ab_acc);
longname = ab_account_longname(ab_acc);
currency = AB_Account_GetCurrency(ab_acc);
if (currency && *currency)
{
commodity = gnc_commodity_table_lookup(
gnc_commodity_table_get_table(gnc_get_current_book()),
GNC_COMMODITY_NS_CURRENCY,
currency);
}
gnc_acc = gnc_import_select_account(info->window, NULL, TRUE,
longname, commodity, ACCT_TYPE_BANK,
old_value, &ok_pressed);
g_free(longname);
if (ok_pressed && old_value != gnc_acc)
{
if (gnc_acc)
{
RevLookupData data;
/* Lookup and clear other mappings to gnc_acc */
data.gnc_acc = gnc_acc;
data.ab_acc = NULL;
g_hash_table_find(info->gnc_hash, (GHRFunc) find_gnc_acc_cb,
&data);
if (data.ab_acc)
{
g_hash_table_remove(info->gnc_hash, data.ab_acc);
gtk_tree_model_foreach(
GTK_TREE_MODEL(info->account_store),
(GtkTreeModelForeachFunc) clear_line_cb,
&data);
}
/* Map ab_acc to gnc_acc */
g_hash_table_insert(info->gnc_hash, ab_acc, gnc_acc);
gnc_name = gnc_account_get_full_name(gnc_acc);
gtk_list_store_set(info->account_store, &iter,
ACCOUNT_LIST_COL_GNC_NAME, gnc_name,
ACCOUNT_LIST_COL_CHECKED, TRUE,
-1);
g_free(gnc_name);
}
else
{
g_hash_table_remove(info->gnc_hash, ab_acc);
gtk_list_store_set(info->account_store, &iter,
ACCOUNT_LIST_COL_GNC_NAME, "",
ACCOUNT_LIST_COL_CHECKED, TRUE,
-1);
}
}
}
}
/**************************************************
* save
*
* save settings to a key file
**************************************************/
bool
CsvTransSettings::save (void)
{
if (trans_preset_is_reserved_name (m_name))
{
PWARN ("Ignoring attempt to save to reserved name '%s'", m_name.c_str());
return true;
}
if ((m_name.find('[') != std::string::npos))
{
PWARN ("Name '%s' contains invalid characters '[]'. Refusing to save", m_name.c_str());
return true;
}
auto keyfile = gnc_state_get_current ();
auto group = csv_group_prefix + m_name;
// Drop previous saved settings with this name
g_key_file_remove_group (keyfile, group.c_str(), nullptr);
// Start Saving the settings
g_key_file_set_string (keyfile, group.c_str(), CSV_NAME, m_name.c_str());
g_key_file_set_boolean (keyfile, group.c_str(), CSV_MULTI_SPLIT, m_multi_split);
g_key_file_set_integer (keyfile, group.c_str(), CSV_SKIP_START, m_skip_start_lines);
g_key_file_set_integer (keyfile, group.c_str(), CSV_SKIP_END, m_skip_end_lines);
g_key_file_set_boolean (keyfile, group.c_str(), CSV_SKIP_ALT, m_skip_alt_lines);
g_key_file_set_boolean (keyfile, group.c_str(), CSV_FORMAT,
(m_file_format == GncImpFileFormat::CSV) ? true : false);
g_key_file_set_string (keyfile, group.c_str(), CSV_SEP, m_separators.c_str());
g_key_file_set_integer (keyfile, group.c_str(), CSV_DATE, m_date_format);
std::ostringstream cmt_ss;
cmt_ss << "Supported date formats: ";
int fmt_num = 0;
std::for_each (GncDate::c_formats.cbegin(), GncDate::c_formats.cend(),
[&cmt_ss, &fmt_num](const GncDateFormat& fmt)
{ cmt_ss << fmt_num++ << ": '" << fmt.m_fmt << "', "; });
auto cmt = cmt_ss.str().substr(0, static_cast<long>(cmt_ss.tellp()) - 2);
g_key_file_set_comment (keyfile, group.c_str(), CSV_DATE,
cmt.c_str(), nullptr);
g_key_file_set_integer (keyfile, group.c_str(), CSV_CURRENCY, m_currency_format);
g_key_file_set_string (keyfile, group.c_str(), CSV_ENCODING, m_encoding.c_str());
if (m_base_account)
g_key_file_set_string (keyfile, group.c_str(), CSV_ACCOUNT, gnc_account_get_full_name(m_base_account));
std::vector<const char*> col_types_str;
for (auto col_type : m_column_types)
col_types_str.push_back(gnc_csv_col_type_strs[col_type]);
if (!col_types_str.empty())
g_key_file_set_string_list (keyfile, group.c_str(), CSV_COL_TYPES,
col_types_str.data(), col_types_str.size());
if (!m_column_widths.empty())
g_key_file_set_integer_list (keyfile, group.c_str(), CSV_COL_WIDTHS,
(gint*)(m_column_widths.data()), m_column_widths.size());
// Do a test read of encoding
GError *key_error = nullptr;
bool error = false;
auto enc_val = g_key_file_get_string (keyfile, group.c_str(), CSV_ENCODING, &key_error);
auto enc_str = std::string{enc_val};
if (enc_val)
g_free (enc_val);
if ((key_error) || (enc_str != m_encoding.c_str()))
{
if (key_error)
{
g_warning ("Error reading group %s key %s: %s", group.c_str(), CSV_COL_TYPES, key_error->message);
g_error_free (key_error);
}
else
g_warning ("Error comparing group %s key %s: '%s' and '%s'", group.c_str(), CSV_COL_TYPES, enc_str.c_str(), group.c_str());
error = true;
}
return error;
}
static void
refresh_model_row (GNCImportMainMatcher *gui,
GtkTreeModel *model,
GtkTreeIter *iter,
GNCImportTransInfo *info)
{
GtkListStore *store;
GtkTreeSelection *selection;
gchar *tmp, *imbalance, *text, *color;
const gchar *ro_text;
Split *split;
g_assert (gui);
g_assert (model);
g_assert (info);
/*DEBUG("Begin");*/
store = GTK_LIST_STORE(model);
gtk_list_store_set(store, iter, DOWNLOADED_COL_DATA, info, -1);
/*Account:*/
split = gnc_import_TransInfo_get_fsplit (info);
g_assert(split); // Must not be NULL
ro_text = xaccAccountGetName(xaccSplitGetAccount(split));
gtk_list_store_set(store, iter, DOWNLOADED_COL_ACCOUNT, ro_text, -1);
/*Date*/
text = qof_print_date ( xaccTransGetDate( gnc_import_TransInfo_get_trans(info) ) );
gtk_list_store_set(store, iter, DOWNLOADED_COL_DATE, text, -1);
g_free(text);
/*Amount*/
ro_text = xaccPrintAmount
(xaccSplitGetAmount (split),
gnc_split_amount_print_info(split, TRUE)
);
gtk_list_store_set(store, iter, DOWNLOADED_COL_AMOUNT, ro_text, -1);
/*Description*/
ro_text = xaccTransGetDescription(gnc_import_TransInfo_get_trans(info) );
gtk_list_store_set(store, iter, DOWNLOADED_COL_DESCRIPTION, ro_text, -1);
/*Memo*/
ro_text = xaccSplitGetMemo(split);
gtk_list_store_set(store, iter, DOWNLOADED_COL_MEMO, ro_text, -1);
/*Actions*/
/* Action informations */
ro_text = text = color = NULL;
switch (gnc_import_TransInfo_get_action(info))
{
case GNCImport_ADD:
if (gnc_import_TransInfo_is_balanced(info) == TRUE)
{
ro_text = _("New, already balanced");
color = COLOR_GREEN;
}
else
{
/* Assume that importers won't create transactions in two or more
currencies so we can use xaccTransGetImbalanceValue */
imbalance =
g_strdup
(xaccPrintAmount
(gnc_numeric_neg(xaccTransGetImbalanceValue
(gnc_import_TransInfo_get_trans(info) )),
gnc_commodity_print_info
(xaccTransGetCurrency(gnc_import_TransInfo_get_trans (info)),
TRUE) ));
if (gnc_import_TransInfo_get_destacc (info) != NULL)
{
color = COLOR_GREEN;
tmp = gnc_account_get_full_name
(gnc_import_TransInfo_get_destacc (info));
if (gnc_import_TransInfo_get_destacc_selected_manually(info)
== TRUE)
{
text =
/* Translators: %1$s is the amount to be
transferred. %2$s is the destination account. */
g_strdup_printf(_("New, transfer %s to (manual) \"%s\""),
imbalance, tmp);
}
else
{
text =
/* Translators: %1$s is the amount to be
transferred. %2$s is the destination account. */
g_strdup_printf(_("New, transfer %s to (auto) \"%s\""),
imbalance, tmp);
}
g_free (tmp);
}
else
{
color = COLOR_YELLOW;
text =
/* Translators: %s is the amount to be transferred. */
g_strdup_printf(_("New, UNBALANCED (need acct to transfer %s)!"),
imbalance);
}
g_free (imbalance);
}
break;
case GNCImport_CLEAR:
if (gnc_import_TransInfo_get_selected_match(info))
{
color = COLOR_GREEN;
if (gnc_import_TransInfo_get_match_selected_manually(info) == TRUE)
{
ro_text = _("Reconcile (manual) match");
}
else
{
ro_text = _("Reconcile (auto) match");
}
}
else
{
color = COLOR_RED;
ro_text = _("Match missing!");
}
break;
case GNCImport_UPDATE:
if (gnc_import_TransInfo_get_selected_match(info))
{
color = COLOR_GREEN;
if (gnc_import_TransInfo_get_match_selected_manually(info) == TRUE)
{
ro_text = _("Update and reconcile (manual) match");
}
else
{
ro_text = _("Update and reconcile (auto) match");
}
}
else
{
color = COLOR_RED;
ro_text = _("Match missing!");
}
break;
case GNCImport_SKIP:
color = COLOR_RED;
ro_text = _("Do not import (no action selected)");
break;
default:
color = "white";
ro_text = "WRITEME, this is an unknown action";
break;
}
gtk_list_store_set(store, iter,
DOWNLOADED_COL_COLOR, color,
DOWNLOADED_COL_ACTION_INFO, ro_text ? ro_text : text,
-1);
if (text)
g_free(text);
/* Set the pixmaps */
gtk_list_store_set(store, iter,
DOWNLOADED_COL_ACTION_ADD,
gnc_import_TransInfo_get_action(info) == GNCImport_ADD,
-1);
if (gnc_import_TransInfo_get_action(info) == GNCImport_SKIP)
{
/*Show the best match's confidence pixmap in the info column*/
gtk_list_store_set(store, iter,
DOWNLOADED_COL_ACTION_PIXBUF,
gen_probability_pixbuf( gnc_import_MatchInfo_get_probability
( gnc_import_TransInfo_get_selected_match (info)),
gui->user_settings,
GTK_WIDGET(gui->view)),
-1);
}
gtk_list_store_set(store, iter,
DOWNLOADED_COL_ACTION_CLEAR,
gnc_import_TransInfo_get_action(info) == GNCImport_CLEAR,
-1);
if (gnc_import_TransInfo_get_action(info) == GNCImport_CLEAR)
{
/*Show the best match's confidence pixmap in the info column*/
gtk_list_store_set(store, iter,
DOWNLOADED_COL_ACTION_PIXBUF,
gen_probability_pixbuf( gnc_import_MatchInfo_get_probability
( gnc_import_TransInfo_get_selected_match (info)),
gui->user_settings,
GTK_WIDGET(gui->view)),
-1);
}
gtk_list_store_set(store, iter,
DOWNLOADED_COL_ACTION_UPDATE,
gnc_import_TransInfo_get_action(info) == GNCImport_UPDATE,
-1);
if (gnc_import_TransInfo_get_action(info) == GNCImport_UPDATE)
{
/*Show the best match's confidence pixmap in the info column*/
gtk_list_store_set(store, iter,
DOWNLOADED_COL_ACTION_PIXBUF,
gen_probability_pixbuf( gnc_import_MatchInfo_get_probability
( gnc_import_TransInfo_get_selected_match (info)),
gui->user_settings,
GTK_WIDGET(gui->view)),
-1);
}
selection = gtk_tree_view_get_selection(gui->view);
gtk_tree_selection_unselect_all(selection);
}
