void
tax_table_delete_entry_cb (GtkButton *button, TaxTableWindow *ttw)
{
g_return_if_fail (ttw);
if (!ttw->current_table || !ttw->current_entry)
return;
if (g_list_length (gncTaxTableGetEntries (ttw->current_table)) <= 1)
{
char *message = _("You cannot remove the last entry from the tax table. "
"Try deleting the tax table if you want to do that.");
gnc_error_dialog (ttw->dialog, "%s", message);
return;
}
if (gnc_verify_dialog (ttw->dialog, FALSE, "%s",
_("Are you sure you want to delete this entry?")))
{
/* Ok, let's remove it */
gnc_suspend_gui_refresh ();
gncTaxTableBeginEdit (ttw->current_table);
gncTaxTableRemoveEntry (ttw->current_table, ttw->current_entry);
gncTaxTableEntryDestroy (ttw->current_entry);
gncTaxTableChanged (ttw->current_table);
gncTaxTableCommitEdit (ttw->current_table);
ttw->current_entry = NULL;
gnc_resume_gui_refresh ();
}
}
void
tax_table_delete_table_cb (GtkButton *button, TaxTableWindow *ttw)
{
g_return_if_fail (ttw);
if (!ttw->current_table)
return;
if (gncTaxTableGetRefcount (ttw->current_table) > 0)
{
char *message =
g_strdup_printf (_("Tax table \"%s\" is in use. You cannot delete it."),
gncTaxTableGetName (ttw->current_table));
gnc_error_dialog (ttw->dialog, "%s", message);
g_free (message);
return;
}
if (gnc_verify_dialog (ttw->dialog, FALSE,
_("Are you sure you want to delete \"%s\"?"),
gncTaxTableGetName (ttw->current_table)))
{
/* Ok, let's remove it */
gnc_suspend_gui_refresh ();
gncTaxTableBeginEdit (ttw->current_table);
gncTaxTableDestroy (ttw->current_table);
ttw->current_table = NULL;
ttw->current_entry = NULL;
gnc_resume_gui_refresh ();
}
}
static void gnc_ui_to_job (JobWindow *jw, GncJob *job)
{
gnc_suspend_gui_refresh ();
gncJobBeginEdit (job);
qof_event_gen(QOF_INSTANCE(job), QOF_EVENT_ADD, NULL);
gncJobSetID (job, gtk_editable_get_chars (GTK_EDITABLE (jw->id_entry),
0, -1));
gncJobSetName (job, gtk_editable_get_chars (GTK_EDITABLE (jw->name_entry),
0, -1));
gncJobSetReference (job, gtk_editable_get_chars
(GTK_EDITABLE (jw->desc_entry), 0, -1));
gncJobSetActive (job, gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON
(jw->active_check)));
{
GncOwner * old = gncJobGetOwner (job);
gnc_owner_get_owner (jw->cust_edit, &(jw->owner));
if (! gncOwnerEqual (old, &(jw->owner)))
gncJobSetOwner (job, &(jw->owner));
}
gncJobCommitEdit (job);
gnc_resume_gui_refresh ();
}
void
gxi_cancel_cb (GtkAssistant *gtkassistant, GncXmlImportData *data)
{
gnc_suspend_gui_refresh ();
data->canceled = TRUE;
gnc_resume_gui_refresh ();
gtk_main_quit();
}
static void
gnc_plugin_log_replay_cmd_new_log_replay (GtkAction *action,
GncMainWindowActionData *data)
{
gnc_suspend_gui_refresh();
gnc_file_log_replay ();
gnc_resume_gui_refresh();
}
static void gnc_ui_to_employee (EmployeeWindow *ew, GncEmployee *employee)
{
GncAddress *addr;
addr = gncEmployeeGetAddr (employee);
gnc_suspend_gui_refresh ();
gncEmployeeBeginEdit (employee);
if (ew->dialog_type == NEW_EMPLOYEE)
qof_event_gen(QOF_INSTANCE(employee), QOF_EVENT_ADD, NULL);
gncEmployeeSetID (employee, gtk_editable_get_chars
(GTK_EDITABLE (ew->id_entry), 0, -1));
gncEmployeeSetUsername (employee, gtk_editable_get_chars
(GTK_EDITABLE (ew->username_entry), 0, -1));
gncAddressSetName (addr, gtk_editable_get_chars
(GTK_EDITABLE (ew->name_entry), 0, -1));
gncAddressSetAddr1 (addr, gtk_editable_get_chars
(GTK_EDITABLE (ew->addr1_entry), 0, -1));
gncAddressSetAddr2 (addr, gtk_editable_get_chars
(GTK_EDITABLE (ew->addr2_entry), 0, -1));
gncAddressSetAddr3 (addr, gtk_editable_get_chars
(GTK_EDITABLE (ew->addr3_entry), 0, -1));
gncAddressSetAddr4 (addr, gtk_editable_get_chars
(GTK_EDITABLE (ew->addr4_entry), 0, -1));
gncAddressSetPhone (addr, gtk_editable_get_chars
(GTK_EDITABLE (ew->phone_entry), 0, -1));
gncAddressSetFax (addr, gtk_editable_get_chars
(GTK_EDITABLE (ew->fax_entry), 0, -1));
gncAddressSetEmail (addr, gtk_editable_get_chars
(GTK_EDITABLE (ew->email_entry), 0, -1));
gncEmployeeSetActive (employee, gtk_toggle_button_get_active
(GTK_TOGGLE_BUTTON (ew->active_check)));
gncEmployeeSetLanguage (employee, gtk_editable_get_chars
(GTK_EDITABLE (ew->language_entry), 0, -1));
/* Parse and set the workday and rate amounts */
gncEmployeeSetWorkday (employee, gnc_amount_edit_get_amount
(GNC_AMOUNT_EDIT (ew->workday_amount)));
gncEmployeeSetRate (employee, gnc_amount_edit_get_amount
(GNC_AMOUNT_EDIT (ew->rate_amount)));
gncEmployeeSetCurrency (employee, gnc_currency_edit_get_currency
(GNC_CURRENCY_EDIT (ew->currency_edit)));
/* Fill in the CCard Acct */
gncEmployeeSetCCard (employee,
(gtk_toggle_button_get_active
(GTK_TOGGLE_BUTTON (ew->ccard_acct_check)) ?
gnc_account_sel_get_account
(GNC_ACCOUNT_SEL (ew->ccard_acct_sel)) : NULL));
gncEmployeeCommitEdit (employee);
gnc_resume_gui_refresh ();
}
static void
dialog_response_cb(GtkDialog *dialog, gint response_id, GncSxSinceLastRunDialog *app_dialog)
{
switch (response_id)
{
case GTK_RESPONSE_OK:
// @@fixme validate current state(GError *errs);
// - [ ] instance state constraints
// - [x] required variable binding
// - [?] ability to create transactions
{
GList *unbound_variables;
unbound_variables = gnc_sx_instance_model_check_variables(app_dialog->editing_model->instances);
g_message("%d variables unbound", g_list_length(unbound_variables));
if (g_list_length(unbound_variables) > 0)
{
// focus first variable
GncSxVariableNeeded *first_unbound;
GtkTreePath *variable_path;
GtkTreeViewColumn *variable_col;
gint variable_view_column = 2;
gboolean start_editing = TRUE;
first_unbound = (GncSxVariableNeeded*)unbound_variables->data;
variable_path = _get_path_for_variable(app_dialog->editing_model, first_unbound->instance, first_unbound->variable);
variable_col = gtk_tree_view_get_column(app_dialog->instance_view, variable_view_column);
gtk_tree_view_set_cursor(app_dialog->instance_view, variable_path, variable_col, start_editing);
gtk_tree_path_free(variable_path);
g_list_foreach(unbound_variables, (GFunc)g_free, NULL);
g_list_free(unbound_variables);
return;
}
}
gnc_suspend_gui_refresh();
gnc_sx_slr_model_effect_change(app_dialog->editing_model, FALSE, &app_dialog->created_txns, NULL);
gnc_resume_gui_refresh();
if (gtk_toggle_button_get_active(app_dialog->review_created_txns_toggle)
&& g_list_length(app_dialog->created_txns) > 0)
{
_show_created_transactions(app_dialog, app_dialog->created_txns);
}
g_list_free(app_dialog->created_txns);
app_dialog->created_txns = NULL;
/* FALL THROUGH */
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
gnc_close_gui_component(app_dialog->component_id);
break;
default:
g_error("unknown response id [%d]", response_id);
break;
}
}
void
on_cancel (GtkAssistant *gtkassistant,
hierarchy_data *data)
{
gnc_suspend_gui_refresh ();
if (data->new_book)
gtk_dialog_response(GTK_DIALOG(gnc_options_dialog_widget (data->optionwin)), GTK_RESPONSE_CANCEL);
delete_hierarchy_dialog (data);
delete_our_account_tree (data);
g_free(data);
gnc_resume_gui_refresh ();
}
void
on_finish (GtkAssistant *gtkassistant,
hierarchy_data *data)
{
GncHierarchyAssistantFinishedCallback when_completed;
gnc_commodity *com;
Account * root;
ENTER (" ");
com = gnc_currency_edit_get_currency (GNC_CURRENCY_EDIT(data->currency_selector));
if (data->our_account_tree)
{
gnc_account_foreach_descendant (data->our_account_tree,
(AccountCb)starting_balance_helper,
data);
}
/* Set book options based on the user's choices */
if (data->new_book)
finish_book_options_helper(data->optionwin, data->options);
// delete before we suspend GUI events, and then muck with the model,
// because the model doesn't seem to handle this correctly.
if (data->initial_category)
gtk_tree_row_reference_free(data->initial_category);
delete_hierarchy_dialog (data);
gnc_suspend_gui_refresh ();
if (data->new_book)
gtk_dialog_response(GTK_DIALOG(gnc_options_dialog_widget (data->optionwin)), GTK_RESPONSE_CANCEL);
account_trees_merge(gnc_get_current_root_account(), data->our_account_tree);
delete_our_account_tree (data);
when_completed = data->when_completed;
g_free(data);
root = gnc_get_current_root_account();
xaccAccountSetCommodity(root, com);
gnc_resume_gui_refresh ();
if (when_completed)
{
(*when_completed)();
}
LEAVE (" ");
}
void
gnc_reconcile_view_commit (GNCReconcileView *view, time64 date)
{
g_return_if_fail (view != NULL);
g_return_if_fail (GNC_IS_RECONCILE_VIEW (view));
if (view->reconciled == NULL)
return;
gnc_suspend_gui_refresh();
g_hash_table_foreach (view->reconciled, grv_commit_hash_helper, &date);
gnc_resume_gui_refresh();
}
void
gnc_bi_import_gui_destroy_cb (GtkWidget *widget, gpointer data)
{
BillImportGui *gui = data;
gnc_suspend_gui_refresh ();
gnc_unregister_gui_component (gui->component_id);
gnc_resume_gui_refresh ();
g_object_unref (gui->store);
g_string_free (gui->regexp, TRUE);
g_free (gui);
}
static void gnc_entry_ledger_move_cursor (VirtualLocation *p_new_virt_loc,
gpointer user_data)
{
GncEntryLedger *ledger = user_data;
VirtualLocation new_virt_loc = *p_new_virt_loc;
GncEntry *new_entry;
GncEntry *old_entry;
gboolean saved;
if (!ledger) return;
old_entry = gnc_entry_ledger_get_current_entry (ledger);
new_entry = gnc_entry_ledger_get_entry (ledger, new_virt_loc.vcell_loc);
gnc_suspend_gui_refresh ();
saved = gnc_entry_ledger_save (ledger, old_entry != new_entry);
gnc_resume_gui_refresh ();
/* redrawing can muck everything up */
if (saved)
{
VirtualCellLocation vcell_loc;
/* redraw */
gnc_entry_ledger_display_refresh (ledger);
if (ledger->traverse_to_new)
new_entry = gnc_entry_ledger_get_blank_entry (ledger);
/* if the entry we were going to is still in the register,
* then it may have moved. Find out where it is now. */
if (gnc_entry_ledger_find_entry (ledger, new_entry, &vcell_loc))
{
VirtualCell *vcell;
vcell = gnc_table_get_virtual_cell (ledger->table, vcell_loc);
new_virt_loc.vcell_loc = vcell_loc;
}
else
new_virt_loc.vcell_loc = ledger->table->current_cursor_loc.vcell_loc;
}
gnc_table_find_close_valid_cell (ledger->table, &new_virt_loc, FALSE);
*p_new_virt_loc = new_virt_loc;
}
static Split*
create_blank_split (Account *default_account, SRInfo *info)
{
Transaction *new_trans;
gboolean currency_from_account = TRUE;
Split *blank_split = NULL;
/* Determine the proper currency to use for this transaction.
* if default_account != NULL and default_account->commodity is
* a currency, then use that. Otherwise use the default currency.
*/
gnc_commodity * currency = gnc_account_or_default_currency(default_account, ¤cy_from_account);
if (default_account != NULL && !currency_from_account)
{
/* If we don't have a currency then pop up a warning dialog */
gnc_info_dialog(NULL, "%s",
_("Could not determine the account currency. "
"Using the default currency provided by your system."));
}
gnc_suspend_gui_refresh ();
new_trans = xaccMallocTransaction (gnc_get_current_book ());
xaccTransBeginEdit (new_trans);
xaccTransSetCurrency (new_trans, currency);
xaccTransSetDatePostedSecsNormalized(new_trans, info->last_date_entered);
blank_split = xaccMallocSplit (gnc_get_current_book ());
xaccSplitSetParent(blank_split, new_trans);
/* We don't want to commit this transaction yet, because the split
doesn't even belong to an account yet. But, we don't want to
set this transaction as the pending transaction either, because
we want to pretend that it hasn't been changed. We depend on
some other code (somewhere) to commit this transaction if we
really edit it, even though it's not marked as the pending
transaction. */
info->blank_split_guid = *xaccSplitGetGUID (blank_split);
info->blank_split_edited = FALSE;
info->auto_complete = FALSE;
DEBUG("created new blank_split=%p", blank_split);
gnc_resume_gui_refresh ();
return blank_split;
}
void
gnc_employee_window_destroy_cb (GtkWidget *widget, gpointer data)
{
EmployeeWindow *ew = data;
GncEmployee *employee = ew_get_employee (ew);
gnc_suspend_gui_refresh ();
if (ew->dialog_type == NEW_EMPLOYEE && employee != NULL)
{
gncEmployeeBeginEdit (employee);
gncEmployeeDestroy (employee);
ew->employee_guid = *guid_null ();
}
gnc_unregister_gui_component (ew->component_id);
gnc_resume_gui_refresh ();
g_free (ew);
}
void
gnc_job_window_destroy_cb (GtkWidget *widget, gpointer data)
{
JobWindow *jw = data;
GncJob *job = jw_get_job (jw);
gnc_suspend_gui_refresh ();
if (jw->dialog_type == NEW_JOB && job != NULL)
{
gncJobBeginEdit (job);
gncJobDestroy (job);
jw->job_guid = *guid_null ();
}
gnc_unregister_gui_component (jw->component_id);
gnc_resume_gui_refresh ();
g_free (jw);
}
/********************************************************************\
* gnc_reconcile_view_postpone *
* postpone the reconcile information in the view by setting *
* reconciled splits to cleared status *
* *
* Args: view - view to commit *
* Returns: nothing *
\********************************************************************/
void
gnc_reconcile_view_postpone (GNCReconcileView *view)
{
GtkTreeModel *model;
GtkTreeIter iter;
int num_splits;
int i;
gpointer entry = NULL;
g_return_if_fail (view != NULL);
g_return_if_fail (GNC_IS_RECONCILE_VIEW (view));
if (view->reconciled == NULL)
return;
model = gtk_tree_view_get_model (GTK_TREE_VIEW (GNC_QUERY_VIEW (view)));
gtk_tree_model_get_iter_first (model, &iter);
num_splits = gnc_query_view_get_num_entries (GNC_QUERY_VIEW (view));
gnc_suspend_gui_refresh();
for (i = 0; i < num_splits; i++)
{
char recn;
gtk_tree_model_get (model, &iter, REC_POINTER, &entry, -1);
// Don't change splits past reconciliation date that haven't been
// set to be reconciled
if (gnc_difftime (view->statement_date,
xaccTransGetDate (xaccSplitGetParent (entry))) >= 0 ||
g_hash_table_lookup (view->reconciled, entry))
{
recn = g_hash_table_lookup (view->reconciled, entry) ? CREC : NREC;
xaccSplitSetReconcile (entry, recn);
}
gtk_tree_model_iter_next (model, &iter);
}
gnc_resume_gui_refresh();
}
void
gnc_customer_window_destroy_cb (GtkWidget *widget, gpointer data)
{
CustomerWindow *cw = data;
GncCustomer *customer = cw_get_customer (cw);
gnc_suspend_gui_refresh ();
if (cw->dialog_type == NEW_CUSTOMER && customer != NULL)
{
gncCustomerBeginEdit (customer);
gncCustomerDestroy (customer);
cw->customer_guid = *guid_null ();
}
if (cw->addrX_selection_source_id)
g_source_remove (cw->addrX_selection_source_id);
gnc_unregister_gui_component (cw->component_id);
gnc_resume_gui_refresh ();
g_free (cw);
}
void
on_choose_account_categories_prepare (hierarchy_data *data)
{
GtkTextBuffer* buffer;
if (!data->account_list_added)
{
/* clear out the description/tree */
if (data->category_accounts_tree)
gtk_widget_destroy(GTK_WIDGET(data->category_accounts_tree));
data->category_accounts_tree = NULL;
buffer = gtk_text_view_get_buffer(data->category_description);
gtk_text_buffer_set_text(buffer, "", -1);
data->account_list_added = TRUE;
/* Build the categories tree if necessary */
gnc_suspend_gui_refresh ();
account_categories_tree_view_prepare (data);
gnc_resume_gui_refresh ();
}
categories_page_enable_next(data);
}
static void gnc_ui_to_customer (CustomerWindow *cw, GncCustomer *cust)
{
GtkTextBuffer* text_buffer;
GtkTextIter start, end;
gchar *text;
GncAddress *addr, *shipaddr;
addr = gncCustomerGetAddr (cust);
shipaddr = gncCustomerGetShipAddr (cust);
gnc_suspend_gui_refresh ();
gncCustomerBeginEdit (cust);
if (cw->dialog_type == NEW_CUSTOMER)
qof_event_gen(QOF_INSTANCE(cust), QOF_EVENT_ADD, NULL);
gncCustomerSetID (cust, gtk_editable_get_chars
(GTK_EDITABLE (cw->id_entry), 0, -1));
gncCustomerSetName (cust, gtk_editable_get_chars
(GTK_EDITABLE (cw->company_entry), 0, -1));
gncAddressSetName (addr, gtk_editable_get_chars
(GTK_EDITABLE (cw->name_entry), 0, -1));
gncAddressSetAddr1 (addr, gtk_editable_get_chars
(GTK_EDITABLE (cw->addr1_entry), 0, -1));
gncAddressSetAddr2 (addr, gtk_editable_get_chars
(GTK_EDITABLE (cw->addr2_entry), 0, -1));
gncAddressSetAddr3 (addr, gtk_editable_get_chars
(GTK_EDITABLE (cw->addr3_entry), 0, -1));
gncAddressSetAddr4 (addr, gtk_editable_get_chars
(GTK_EDITABLE (cw->addr4_entry), 0, -1));
gncAddressSetPhone (addr, gtk_editable_get_chars
(GTK_EDITABLE (cw->phone_entry), 0, -1));
gncAddressSetFax (addr, gtk_editable_get_chars
(GTK_EDITABLE (cw->fax_entry), 0, -1));
gncAddressSetEmail (addr, gtk_editable_get_chars
(GTK_EDITABLE (cw->email_entry), 0, -1));
gncAddressSetName (shipaddr, gtk_editable_get_chars
(GTK_EDITABLE (cw->shipname_entry), 0, -1));
gncAddressSetAddr1 (shipaddr, gtk_editable_get_chars
(GTK_EDITABLE (cw->shipaddr1_entry), 0, -1));
gncAddressSetAddr2 (shipaddr, gtk_editable_get_chars
(GTK_EDITABLE (cw->shipaddr2_entry), 0, -1));
gncAddressSetAddr3 (shipaddr, gtk_editable_get_chars
(GTK_EDITABLE (cw->shipaddr3_entry), 0, -1));
gncAddressSetAddr4 (shipaddr, gtk_editable_get_chars
(GTK_EDITABLE (cw->shipaddr4_entry), 0, -1));
gncAddressSetPhone (shipaddr, gtk_editable_get_chars
(GTK_EDITABLE (cw->shipphone_entry), 0, -1));
gncAddressSetFax (shipaddr, gtk_editable_get_chars
(GTK_EDITABLE (cw->shipfax_entry), 0, -1));
gncAddressSetEmail (shipaddr, gtk_editable_get_chars
(GTK_EDITABLE (cw->shipemail_entry), 0, -1));
gncCustomerSetActive (cust, gtk_toggle_button_get_active
(GTK_TOGGLE_BUTTON (cw->active_check)));
gncCustomerSetTaxIncluded (cust, cw->taxincluded);
text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW(cw->notes_text));
gtk_text_buffer_get_bounds (text_buffer, &start, &end);
text = gtk_text_buffer_get_text (text_buffer, &start, &end, FALSE);
gncCustomerSetNotes (cust, text);
/* Parse and set the currency, terms, discount, and credit amounts */
gncCustomerSetCurrency (cust,
gnc_currency_edit_get_currency (GNC_CURRENCY_EDIT
(cw->currency_edit)));
gncCustomerSetTerms (cust, cw->terms);
gncCustomerSetDiscount (cust, gnc_amount_edit_get_amount
(GNC_AMOUNT_EDIT (cw->discount_amount)));
gncCustomerSetCredit (cust, gnc_amount_edit_get_amount
(GNC_AMOUNT_EDIT (cw->credit_amount)));
gncCustomerSetTaxTableOverride
(cust, gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (cw->taxtable_check)));
gncCustomerSetTaxTable (cust, cw->taxtable);
gncCustomerCommitEdit (cust);
gnc_resume_gui_refresh ();
}
static guint
sxftd_add_template_trans(SXFromTransInfo *sxfti)
{
Transaction *tr = sxfti->trans;
GList *tt_list = NULL;
GList *splits, *template_splits = NULL;
TTInfo *tti = gnc_ttinfo_malloc();
TTSplitInfo *ttsi;
Split *sp;
gnc_numeric runningBalance;
gnc_numeric split_value;
const char *tmpStr;
runningBalance = gnc_numeric_zero();
gnc_ttinfo_set_description(tti, xaccTransGetDescription(tr));
gnc_ttinfo_set_num(tti, gnc_get_num_action(tr, NULL));
gnc_ttinfo_set_currency(tti, xaccTransGetCurrency(tr));
for (splits = xaccTransGetSplitList(tr); splits; splits = splits->next)
{
sp = splits->data;
ttsi = gnc_ttsplitinfo_malloc();
gnc_ttsplitinfo_set_action(ttsi, gnc_get_num_action(NULL, sp));
split_value = xaccSplitGetValue(sp);
gnc_ttsplitinfo_set_memo(ttsi, xaccSplitGetMemo(sp));
runningBalance = gnc_numeric_add( runningBalance, split_value,
100, (GNC_DENOM_AUTO | GNC_HOW_DENOM_LCD) );
if (gnc_numeric_positive_p(split_value))
{
tmpStr = xaccPrintAmount( split_value,
gnc_default_print_info(FALSE) );
gnc_ttsplitinfo_set_debit_formula( ttsi, tmpStr );
}
else
{
/* Negate the numeric so it prints w/o the sign at the front. */
tmpStr = xaccPrintAmount( gnc_numeric_neg( split_value ),
gnc_default_print_info(FALSE) );
gnc_ttsplitinfo_set_credit_formula( ttsi, tmpStr );
}
/* Copy over per-split account info */
gnc_ttsplitinfo_set_account( ttsi, xaccSplitGetAccount( sp ) );
template_splits = g_list_append(template_splits, ttsi);
}
if ( ! gnc_numeric_zero_p( runningBalance )
&& !gnc_verify_dialog( (GtkWidget *)sxfti->dialog,
FALSE, "%s",
_("The Scheduled Transaction Editor "
"cannot automatically balance "
"this transaction. "
"Should it still be "
"entered?") ) )
{
return SXFTD_ERRNO_UNBALANCED_XACTION;
}
gnc_ttinfo_set_template_splits(tti, template_splits);
tt_list = g_list_append(tt_list, tti);
gnc_suspend_gui_refresh ();
xaccSchedXactionSetTemplateTrans(sxfti->sx, tt_list,
gnc_get_current_book ());
gnc_resume_gui_refresh ();
return 0;
}
void
gnc_stock_split_assistant_finish (GtkAssistant *assistant,
gpointer user_data)
{
StockSplitInfo *info = user_data;
GList *account_commits;
GList *node;
gnc_numeric amount;
Transaction *trans;
Account *account;
Split *split;
time64 date;
account = info->acct;
g_return_if_fail (account != NULL);
amount = gnc_amount_edit_get_amount
(GNC_AMOUNT_EDIT (info->distribution_edit));
g_return_if_fail (!gnc_numeric_zero_p (amount));
gnc_suspend_gui_refresh ();
trans = xaccMallocTransaction (gnc_get_current_book ());
xaccTransBeginEdit (trans);
xaccTransSetCurrency (trans, gnc_default_currency ());
date = gnc_date_edit_get_date (GNC_DATE_EDIT (info->date_edit));
xaccTransSetDatePostedSecsNormalized (trans, date);
{
const char *description;
description = gtk_entry_get_text (GTK_ENTRY (info->description_entry));
xaccTransSetDescription (trans, description);
}
split = xaccMallocSplit (gnc_get_current_book ());
xaccAccountBeginEdit (account);
account_commits = g_list_prepend (NULL, account);
xaccTransAppendSplit (trans, split);
xaccAccountInsertSplit (account, split);
xaccSplitSetAmount (split, amount);
xaccSplitMakeStockSplit (split);
/* Set split-action with gnc_set_num_action which is the same as
* xaccSplitSetAction with these arguments */
/* Translators: This string has a disambiguation prefix */
gnc_set_num_action (NULL, split, NULL, Q_("Action Column|Split"));
amount = gnc_amount_edit_get_amount (GNC_AMOUNT_EDIT (info->price_edit));
if (gnc_numeric_positive_p (amount))
{
QofBook *book;
GNCPrice *price;
GNCPriceDB *pdb;
GNCCurrencyEdit *ce;
Timespec ts;
ce = GNC_CURRENCY_EDIT (info->price_currency_edit);
ts.tv_sec = date;
ts.tv_nsec = 0;
price = gnc_price_create (gnc_get_current_book ());
gnc_price_begin_edit (price);
gnc_price_set_commodity (price, xaccAccountGetCommodity (account));
gnc_price_set_currency (price, gnc_currency_edit_get_currency (ce));
gnc_price_set_time (price, ts);
gnc_price_set_source (price, PRICE_SOURCE_STOCK_SPLIT);
gnc_price_set_typestr (price, PRICE_TYPE_UNK);
gnc_price_set_value (price, amount);
gnc_price_commit_edit (price);
book = gnc_get_current_book ();
pdb = gnc_pricedb_get_db (book);
if (!gnc_pricedb_add_price (pdb, price))
gnc_error_dialog (info->window, "%s", _("Error adding price."));
}
amount = gnc_amount_edit_get_amount (GNC_AMOUNT_EDIT (info->cash_edit));
if (gnc_numeric_positive_p (amount))
{
const char *memo;
memo = gtk_entry_get_text (GTK_ENTRY (info->memo_entry));
/* asset split */
account = gnc_tree_view_account_get_selected_account (GNC_TREE_VIEW_ACCOUNT(info->asset_tree));
split = xaccMallocSplit (gnc_get_current_book ());
xaccAccountBeginEdit (account);
account_commits = g_list_prepend (account_commits, account);
xaccAccountInsertSplit (account, split);
xaccTransAppendSplit (trans, split);
xaccSplitSetAmount (split, amount);
xaccSplitSetValue (split, amount);
xaccSplitSetMemo (split, memo);
/* income split */
account = gnc_tree_view_account_get_selected_account (GNC_TREE_VIEW_ACCOUNT(info->income_tree));
split = xaccMallocSplit (gnc_get_current_book ());
xaccAccountBeginEdit (account);
account_commits = g_list_prepend (account_commits, account);
xaccAccountInsertSplit (account, split);
xaccTransAppendSplit (trans, split);
xaccSplitSetAmount (split, gnc_numeric_neg (amount));
xaccSplitSetValue (split, gnc_numeric_neg (amount));
xaccSplitSetMemo (split, memo);
}
xaccTransCommitEdit (trans);
for (node = account_commits; node; node = node->next)
xaccAccountCommitEdit (node->data);
g_list_free (account_commits);
gnc_resume_gui_refresh ();
gnc_close_gui_component_by_data (ASSISTANT_STOCK_SPLIT_CM_CLASS, info);
}
static gboolean
ap_close_period (GnomeDruidPage *druidpage,
GtkWidget *druid,
gpointer user_data)
{
AcctPeriodInfo *info = user_data;
QofBook *closed_book = NULL, *current_book;
const char *btitle;
char *bnotes;
Timespec closing_date;
KvpFrame *book_frame;
gboolean really_do_close_books = FALSE;
ENTER("info=%p", info);
current_book = gnc_get_current_book ();
btitle = gtk_entry_get_text (info->book_title);
bnotes = xxxgtk_textview_get_text (info->book_notes);
PINFO("book title=%s\n", btitle);
timespecFromTime_t (&closing_date,
gnc_timet_get_day_end_gdate (&info->closing_date));
#define REALLY_DO_CLOSE_BOOKS
#ifdef REALLY_DO_CLOSE_BOOKS
really_do_close_books = TRUE;
#endif /* REALLY_DO_CLOSE_BOOKS */
if (really_do_close_books)
{
/* Close the books ! */
qof_event_suspend ();
gnc_suspend_gui_refresh ();
scrub_all();
closed_book = gnc_book_close_period (current_book, closing_date, NULL, btitle);
book_frame = qof_book_get_slots(closed_book);
kvp_frame_set_str (book_frame, "/book/title", btitle);
kvp_frame_set_str (book_frame, "/book/notes", bnotes);
qof_session_add_book (gnc_get_current_session(), closed_book);
/* We must save now; if we don't, and the user bails without saving,
* then opening account balances will be incorrect, and this can only
* lead to unhappiness.
*/
gnc_file_save ();
gnc_resume_gui_refresh ();
qof_event_resume ();
gnc_gui_refresh_all (); /* resume above should have been enough ??? */
}
g_free(bnotes);
/* Report the status back to the user. */
info->close_status = 0; /* XXX fixme success or failure? */
/* Find the next closing date ... */
info->prev_closing_date = info->closing_date;
recurrenceListNextInstance(info->period, &info->prev_closing_date, &info->closing_date);
/* If the next closing date is in the future, then we are done. */
if (time(NULL) < gnc_timet_get_day_end_gdate (&info->closing_date))
{
return FALSE;
}
/* Load up the GUI for the next closing period. */
gnc_frequency_setup_recurrence(info->period_menu, NULL, &info->closing_date);
show_book_details (info);
return TRUE;
}
/* XXX currently not properly implemented, so disabled for now
gnc_ui_job_new (owner, gnc_get_current_book ()); */
break;
}
case GNC_OWNER_VENDOR :
{
gnc_ui_vendor_new (gnc_get_current_book ());
break;
}
case GNC_OWNER_EMPLOYEE :
{
gnc_ui_employee_new (gnc_get_current_book ());
break;
}
}
}
static void
gnc_plugin_page_owner_tree_cmd_edit_owner (GtkAction *action, GncPluginPageOwnerTree *page)
{
GncOwner *owner = gnc_plugin_page_owner_tree_get_current_owner (page);
if (NULL == owner) return;
ENTER("action %p, page %p", action, page);
gnc_ui_owner_edit (owner);
LEAVE(" ");
}
#if 0 /* Disabled due to crash */
static void
gnc_plugin_page_owner_tree_cmd_delete_owner (GtkAction *action, GncPluginPageOwnerTree *page)
{
GncOwner *owner = gnc_plugin_page_owner_tree_get_current_owner (page);
gchar *owner_name;
GtkWidget *window;
GtkWidget *dialog = NULL;
gint response;
GList* list;
if (NULL == owner) return;
/* If the owner has objects referring to it, show the list - the owner can't be deleted until these
references are dealt with. */
list = qof_instance_get_referring_object_list(QOF_INSTANCE(gncOwnerGetUndefined(owner)));
if (list != NULL)
{
#define EXPLANATION "The list below shows objects which make use of the owner which you want to delete.\nBefore you can delete it, you must either delete those objects or else modify them so they make use\nof another owner"
gnc_ui_object_references_show( _(EXPLANATION), list);
g_list_free(list);
return;
}
window = gnc_plugin_page_get_window(GNC_PLUGIN_PAGE(page));
owner_name = g_strdup (gncOwnerGetName(owner));
if (!owner_name)
{
owner_name = g_strdup (_("(no name)"));
}
/*
* Present a message to the user which specifies what will be
* deleted, then ask for verification.
*/
{
char *message = g_strdup_printf(_("The owner %s will be deleted.\nAre you sure you want to do this?"), owner_name);
dialog = gtk_message_dialog_new(GTK_WINDOW(window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_NONE,
"%s", message);
g_free(message);
gtk_dialog_add_buttons(GTK_DIALOG(dialog),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_DELETE, GTK_RESPONSE_ACCEPT,
(gchar *)NULL);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CANCEL);
response = gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
if (GTK_RESPONSE_ACCEPT == response)
{
/* FIXME The code below results in a crash.
* The corresponding menu item/toolbar button is disabled until this is fixed. */
gnc_set_busy_cursor(NULL, TRUE);
gnc_suspend_gui_refresh ();
gncOwnerBeginEdit (owner);
gncOwnerDestroy (owner);
gnc_resume_gui_refresh ();
gnc_unset_busy_cursor(NULL);
}
}
g_free(owner_name);
}
static gboolean
new_tax_table_ok_cb (NewTaxTable *ntt)
{
TaxTableWindow *ttw;
const char *name = NULL;
char *message;
Account *acc;
gnc_numeric amount;
g_return_val_if_fail (ntt, FALSE);
ttw = ntt->ttw;
/* Verify that we've got real, valid data */
/* verify the name, maybe */
if (ntt->new_table)
{
name = gtk_entry_get_text (GTK_ENTRY (ntt->name_entry));
if (name == NULL || *name == '\0')
{
message = _("You must provide a name for this Tax Table.");
gnc_error_dialog (ntt->dialog, "%s", message);
return FALSE;
}
if (gncTaxTableLookupByName (ttw->book, name))
{
message = g_strdup_printf(_(
"You must provide a unique name for this Tax Table. "
"Your choice \"%s\" is already in use."), name);
gnc_error_dialog (ntt->dialog, "%s", message);
g_free (message);
return FALSE;
}
}
/* verify the amount. Note that negative values are allowed (required for European tax rules) */
amount = gnc_amount_edit_get_amount (GNC_AMOUNT_EDIT (ntt->amount_entry));
if (ntt->type == GNC_AMT_TYPE_PERCENT &&
gnc_numeric_compare (gnc_numeric_abs (amount),
gnc_numeric_create (100, 1)) > 0)
{
message = _("Percentage amount must be between -100 and 100.");
gnc_error_dialog (ntt->dialog, "%s", message);
return FALSE;
}
/* verify the account */
acc = gnc_tree_view_account_get_selected_account (GNC_TREE_VIEW_ACCOUNT(ntt->acct_tree));
if (acc == NULL)
{
message = _("You must choose a Tax Account.");
gnc_error_dialog (ntt->dialog, "%s", message);
return FALSE;
}
gnc_suspend_gui_refresh ();
/* Ok, it's all valid, now either change to add this thing */
if (ntt->new_table)
{
GncTaxTable *table = gncTaxTableCreate (ttw->book);
gncTaxTableBeginEdit (table);
gncTaxTableSetName (table, name);
/* Reset the current table */
ttw->current_table = table;
ntt->created_table = table;
}
else
gncTaxTableBeginEdit (ttw->current_table);
/* Create/edit the entry */
{
GncTaxTableEntry *entry;
if (ntt->entry)
{
entry = ntt->entry;
}
else
{
entry = gncTaxTableEntryCreate ();
gncTaxTableAddEntry (ttw->current_table, entry);
ttw->current_entry = entry;
}
gncTaxTableEntrySetAccount (entry, acc);
gncTaxTableEntrySetType (entry, ntt->type);
gncTaxTableEntrySetAmount (entry, amount);
}
/* Mark the table as changed and commit it */
gncTaxTableChanged (ttw->current_table);
gncTaxTableCommitEdit (ttw->current_table);
gnc_resume_gui_refresh();
return TRUE;
}
static gboolean
gnc_entry_ledger_save (GncEntryLedger *ledger, gboolean do_commit)
{
GncEntry *blank_entry;
GncEntry *entry;
if (!ledger) return FALSE;
blank_entry = gnc_entry_ledger_get_blank_entry (ledger);
entry = gnc_entry_ledger_get_current_entry (ledger);
if (entry == NULL) return FALSE;
/* Try to avoid heavy-weight updates if nothing has changed */
if (!gnc_table_current_cursor_changed (ledger->table, FALSE))
{
if (!do_commit) return FALSE;
if (entry == blank_entry)
{
if (ledger->blank_entry_edited)
{
ledger->last_date_entered = gncEntryGetDateGDate (entry);
ledger->blank_entry_guid = *guid_null ();
ledger->blank_entry_edited = FALSE;
blank_entry = NULL;
}
else
return FALSE;
}
return TRUE;
}
gnc_suspend_gui_refresh ();
if (!gncEntryIsOpen (entry))
gncEntryBeginEdit (entry);
gnc_table_save_cells (ledger->table, entry);
if (entry == blank_entry)
{
Timespec ts;
ts.tv_sec = time(NULL);
ts.tv_nsec = 0;
gncEntrySetDateEntered (blank_entry, ts);
switch (ledger->type)
{
case GNCENTRY_ORDER_ENTRY:
gncOrderAddEntry (ledger->order, blank_entry);
break;
case GNCENTRY_INVOICE_ENTRY:
case GNCENTRY_CUST_CREDIT_NOTE_ENTRY:
/* Anything entered on an invoice entry must be part of the invoice! */
gncInvoiceAddEntry (ledger->invoice, blank_entry);
break;
case GNCENTRY_BILL_ENTRY:
case GNCENTRY_EXPVOUCHER_ENTRY:
case GNCENTRY_VEND_CREDIT_NOTE_ENTRY:
case GNCENTRY_EMPL_CREDIT_NOTE_ENTRY:
/* Anything entered on an invoice entry must be part of the invoice! */
gncBillAddEntry (ledger->invoice, blank_entry);
break;
default:
/* Nothing to do for viewers */
g_warning ("blank entry traversed in a viewer");
break;
}
}
if (entry == blank_entry)
{
if (do_commit)
{
ledger->blank_entry_guid = *guid_null ();
blank_entry = NULL;
ledger->last_date_entered = gncEntryGetDateGDate (entry);
}
else
ledger->blank_entry_edited = TRUE;
}
if (do_commit)
gncEntryCommitEdit (entry);
gnc_table_clear_current_cursor_changes (ledger->table);
gnc_resume_gui_refresh ();
return TRUE;
}
void
gnc_payment_ok_cb (GtkWidget *widget, gpointer data)
{
PaymentWindow *pw = data;
const char *text = NULL;
if (!pw)
return;
/* The gnc_payment_window_check_payment function
* ensures we have valid owner, post account, transfer account
* and amount so we can proceed with the payment.
* Note: make sure it's called before all entry points to this function !
*/
gnc_suspend_gui_refresh ();
{
const char *memo, *num;
Timespec date;
gnc_numeric exch = gnc_numeric_create(1, 1); //default to "one to one" rate
GList *selected_lots = NULL;
GtkTreeSelection *selection;
gboolean auto_pay;
/* Obtain all our ancillary information */
memo = gtk_entry_get_text (GTK_ENTRY (pw->memo_entry));
num = gtk_entry_get_text (GTK_ENTRY (pw->num_entry));
date = gnc_date_edit_get_date_ts (GNC_DATE_EDIT (pw->date_edit));
/* Obtain the list of selected lots (documents/payments) from the dialog */
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(pw->docs_list_tree_view));
gtk_tree_selection_selected_foreach (selection, get_selected_lots, &selected_lots);
/* When the payment amount is 0, the selected documents cancel each other out
* so no money is actually transferred.
* For non-zero payments money will be transferred between the post account
* and the transfer account. In that case if these two accounts don't have
* the same currency the user is asked to enter the exchange rate.
*/
if (!gnc_numeric_zero_p (pw->amount_tot) &&
!gnc_commodity_equal(xaccAccountGetCommodity(pw->xfer_acct), xaccAccountGetCommodity(pw->post_acct)))
{
XferDialog* xfer;
text = _("The transfer and post accounts are associated with different currencies. Please specify the conversion rate.");
xfer = gnc_xfer_dialog(pw->dialog, pw->xfer_acct);
gnc_info_dialog(pw->dialog, "%s", text);
gnc_xfer_dialog_select_to_account(xfer, pw->post_acct);
gnc_xfer_dialog_set_amount(xfer, pw->amount_tot);
/* All we want is the exchange rate so prevent the user from thinking
it makes sense to mess with other stuff */
gnc_xfer_dialog_set_from_show_button_active(xfer, FALSE);
gnc_xfer_dialog_set_to_show_button_active(xfer, FALSE);
gnc_xfer_dialog_hide_from_account_tree(xfer);
gnc_xfer_dialog_hide_to_account_tree(xfer);
gnc_xfer_dialog_is_exchange_dialog(xfer, &exch);
gnc_xfer_dialog_run_until_done(xfer);
}
/* Perform the payment */
if (gncOwnerGetType (&(pw->owner)) == GNC_OWNER_CUSTOMER)
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);
gncOwnerApplyPayment (&pw->owner, pw->pre_existing_txn, selected_lots,
pw->post_acct, pw->xfer_acct, pw->amount_tot,
exch, date, memo, num, auto_pay);
}
gnc_resume_gui_refresh ();
/* Save the transfer account, xfer_acct */
gnc_payment_dialog_remember_account(pw, pw->xfer_acct);
gnc_ui_payment_window_destroy (pw);
}
void
on_final_account_prepare (hierarchy_data *data)
{
GSList *actlist;
GtkTreeView *tree_view;
GtkTreeSelection *selection;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
gnc_commodity *com;
/* Anything to do? */
if (!data->category_set_changed)
return;
data->category_set_changed = FALSE;
gnc_suspend_gui_refresh ();
/* Delete any existing account tree */
if (data->final_account_tree)
{
gtk_widget_destroy(GTK_WIDGET(data->final_account_tree));
data->final_account_tree = NULL;
}
delete_our_account_tree (data);
/* Build a new account list */
actlist = get_selected_account_list (data->categories_tree);
com = gnc_currency_edit_get_currency (GNC_CURRENCY_EDIT(data->currency_selector));
data->our_account_tree = hierarchy_merge_accounts (actlist, com);
/* Now build a new account tree */
data->final_account_tree
= GNC_TREE_VIEW_ACCOUNT(gnc_tree_view_account_new_with_root (data->our_account_tree, FALSE));
tree_view = GTK_TREE_VIEW(data->final_account_tree);
gnc_tree_view_account_set_name_edited(data->final_account_tree,
gnc_tree_view_account_name_edited_cb);
gnc_tree_view_account_set_code_edited(data->final_account_tree,
gnc_tree_view_account_code_edited_cb);
gnc_tree_view_account_set_description_edited(data->final_account_tree,
gnc_tree_view_account_description_edited_cb);
gnc_tree_view_account_set_notes_edited(data->final_account_tree,
gnc_tree_view_account_notes_edited_cb);
gtk_tree_view_set_headers_visible (tree_view, TRUE);
column = gnc_tree_view_find_column_by_name (
GNC_TREE_VIEW(data->final_account_tree), "type");
g_object_set_data(G_OBJECT(column), DEFAULT_VISIBLE, GINT_TO_POINTER(1));
gnc_tree_view_configure_columns (GNC_TREE_VIEW(data->final_account_tree));
gnc_tree_view_set_show_column_menu (GNC_TREE_VIEW(data->final_account_tree),
FALSE);
selection = gtk_tree_view_get_selection (tree_view);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
// This is a re-definition of the placeholder that the account-tree model
// provides, reflecting the to-be-created state of the account tree
// post-merge.
{
renderer = gtk_cell_renderer_toggle_new();
g_object_set(G_OBJECT (renderer),
"activatable", FALSE,
"sensitive", FALSE,
NULL);
column = gtk_tree_view_column_new_with_attributes(_("Placeholder"),
renderer, NULL);
gtk_tree_view_column_set_cell_data_func (column, renderer,
placeholder_cell_data_func,
(gpointer)data, NULL);
gnc_tree_view_append_column (GNC_TREE_VIEW(tree_view), column);
}
{
renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer),
"xalign", 1.0,
(char *)NULL);
g_signal_connect (G_OBJECT (renderer), "edited",
G_CALLBACK (balance_cell_edited),
data);
column = gtk_tree_view_column_new_with_attributes (_("Opening Balance"),
renderer,
NULL);
gtk_tree_view_column_set_cell_data_func (column, renderer,
balance_cell_data_func,
(gpointer)data, NULL);
gnc_tree_view_append_column (GNC_TREE_VIEW(tree_view), column);
}
// only in the case where there *are* existing accounts...
if (gnc_account_n_descendants(gnc_book_get_root_account(gnc_get_current_book())) > 0)
{
GList *renderers;
column = gnc_tree_view_add_text_column(GNC_TREE_VIEW(tree_view),
_("Use Existing"),
NULL,
NULL,
"yes",
GNC_TREE_VIEW_COLUMN_DATA_NONE,
GNC_TREE_VIEW_COLUMN_VISIBLE_ALWAYS,
NULL);
renderers = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(column));
g_object_set(G_OBJECT(renderer), "xalign", 1.0, (char*)NULL);
gtk_tree_view_column_set_cell_data_func(column, GTK_CELL_RENDERER(renderers->data),
use_existing_account_data_func, (gpointer)data, NULL);
g_list_free(renderers);
}
gtk_container_add(GTK_CONTAINER(data->final_account_tree_container),
GTK_WIDGET(data->final_account_tree));
/* Expand the entire tree */
gtk_tree_view_expand_all (tree_view);
gtk_widget_show(GTK_WIDGET(data->final_account_tree));
gnc_resume_gui_refresh ();
}
void
gnc_split_register_load (SplitRegister *reg, GList * slist,
Account *default_account)
{
SRInfo *info;
Transaction *pending_trans;
CursorBuffer *cursor_buffer;
GHashTable *trans_table = NULL;
CellBlock *cursor_header;
CellBlock *lead_cursor;
CellBlock *split_cursor;
Transaction *blank_trans;
Transaction *find_trans;
Transaction *trans;
CursorClass find_class;
Split *find_trans_split;
Split *blank_split;
Split *find_split;
Split *split;
Table *table;
GList *node;
gboolean start_primary_color = TRUE;
gboolean found_pending = FALSE;
gboolean need_divider_upper = FALSE;
gboolean found_divider_upper = FALSE;
gboolean found_divider = FALSE;
gboolean has_last_num = FALSE;
gboolean multi_line;
gboolean dynamic;
gboolean we_own_slist = FALSE;
gboolean use_autoreadonly = qof_book_uses_autoreadonly(gnc_get_current_book());
VirtualCellLocation vcell_loc;
VirtualLocation save_loc;
int new_trans_split_row = -1;
int new_trans_row = -1;
int new_split_row = -1;
time64 present, autoreadonly_time = 0;
g_return_if_fail(reg);
table = reg->table;
g_return_if_fail(table);
info = gnc_split_register_get_info (reg);
g_return_if_fail(info);
ENTER("reg=%p, slist=%p, default_account=%p", reg, slist, default_account);
blank_split = xaccSplitLookup (&info->blank_split_guid,
gnc_get_current_book ());
pending_trans = xaccTransLookup (&info->pending_trans_guid,
gnc_get_current_book ());
/* make sure we have a blank split */
if (blank_split == NULL)
{
Transaction *new_trans;
gboolean currency_from_account = TRUE;
/* Determine the proper currency to use for this transaction.
* if default_account != NULL and default_account->commodity is
* a currency, then use that. Otherwise use the default currency.
*/
gnc_commodity * currency = gnc_account_or_default_currency(default_account, ¤cy_from_account);
if (default_account != NULL && !currency_from_account)
{
/* If we don't have a currency then pop up a warning dialog */
gnc_info_dialog(NULL, "%s",
_("Could not determine the account currency. "
"Using the default currency provided by your system."));
}
gnc_suspend_gui_refresh ();
new_trans = xaccMallocTransaction (gnc_get_current_book ());
xaccTransBeginEdit (new_trans);
xaccTransSetCurrency (new_trans, currency);
xaccTransSetDatePostedSecsNormalized(new_trans, info->last_date_entered);
blank_split = xaccMallocSplit (gnc_get_current_book ());
xaccSplitSetParent(blank_split, new_trans);
/* We don't want to commit this transaction yet, because the split
doesn't even belong to an account yet. But, we don't want to
set this transaction as the pending transaction either, because
we want to pretend that it hasn't been changed. We depend on
some other code (somewhere) to commit this transaction if we
really edit it, even though it's not marked as the pending
transaction. */
/* Wouldn't it be a bug to open this transaction if there was already a
pending transaction? */
g_assert(pending_trans == NULL);
info->blank_split_guid = *xaccSplitGetGUID (blank_split);
info->blank_split_edited = FALSE;
info->auto_complete = FALSE;
DEBUG("created new blank_split=%p", blank_split);
gnc_resume_gui_refresh ();
}
blank_trans = xaccSplitGetParent (blank_split);
DEBUG("blank_split=%p, blank_trans=%p, pending_trans=%p",
blank_split, blank_trans, pending_trans);
info->default_account = *xaccAccountGetGUID (default_account);
// gnc_table_leave_update (table, table->current_cursor_loc);
multi_line = (reg->style == REG_STYLE_JOURNAL);
dynamic = (reg->style == REG_STYLE_AUTO_LEDGER);
lead_cursor = gnc_split_register_get_passive_cursor (reg);
split_cursor = gnc_table_layout_get_cursor (table->layout, CURSOR_SPLIT);
/* figure out where we are going to. */
if (info->traverse_to_new)
{
find_trans = blank_trans;
find_split = NULL;
find_trans_split = blank_split;
find_class = CURSOR_CLASS_SPLIT;
}
else
{
find_trans = info->cursor_hint_trans;
find_split = info->cursor_hint_split;
find_trans_split = info->cursor_hint_trans_split;
find_class = info->cursor_hint_cursor_class;
}
save_loc = table->current_cursor_loc;
/* If the current cursor has changed we save the values for later
* possible restoration. */
if (gnc_table_current_cursor_changed (table, TRUE) &&
(find_split == gnc_split_register_get_current_split (reg)))
{
cursor_buffer = gnc_cursor_buffer_new ();
gnc_table_save_current_cursor (table, cursor_buffer);
}
else
cursor_buffer = NULL;
/* disable move callback -- we don't want the cascade of
* callbacks while we are fiddling with loading the register */
gnc_table_control_allow_move (table->control, FALSE);
/* invalidate the cursor */
{
VirtualLocation virt_loc;
gnc_virtual_location_init(&virt_loc);
gnc_table_move_cursor_gui (table, virt_loc);
}
/* make sure that the header is loaded */
vcell_loc.virt_row = 0;
vcell_loc.virt_col = 0;
cursor_header = gnc_table_layout_get_cursor (table->layout, CURSOR_HEADER);
gnc_table_set_vcell (table, cursor_header, NULL, TRUE, TRUE, vcell_loc);
vcell_loc.virt_row++;
/* get the current time and reset the dividing row */
present = gnc_time64_get_today_end ();
if (use_autoreadonly)
{
GDate *d = qof_book_get_autoreadonly_gdate(gnc_get_current_book());
// "d" is NULL if use_autoreadonly is FALSE
autoreadonly_time = d ? timespecToTime64(gdate_to_timespec(*d)) : 0;
g_date_free(d);
}
if (info->first_pass)
{
if (default_account)
{
const char *last_num = xaccAccountGetLastNum (default_account);
if (last_num)
{
NumCell *cell;
cell = (NumCell *) gnc_table_layout_get_cell(table->layout, NUM_CELL);
gnc_num_cell_set_last_num (cell, last_num);
has_last_num = TRUE;
}
}
/* load up account names into the transfer combobox menus */
gnc_split_register_load_xfer_cells (reg, default_account);
gnc_split_register_load_recn_cells (reg);
gnc_split_register_load_type_cells (reg);
}
if (info->separator_changed)
{
info->separator_changed = FALSE;
/* set the completion character for the xfer cells */
gnc_combo_cell_set_complete_char(
(ComboCell *) gnc_table_layout_get_cell(table->layout, MXFRM_CELL),
gnc_get_account_separator());
gnc_combo_cell_set_complete_char(
(ComboCell *) gnc_table_layout_get_cell(table->layout, XFRM_CELL),
gnc_get_account_separator());
/* set the confirmation callback for the reconcile cell */
gnc_recn_cell_set_confirm_cb(
(RecnCell *) gnc_table_layout_get_cell(table->layout, RECN_CELL),
gnc_split_register_recn_cell_confirm, reg);
}
table->model->dividing_row_upper = -1;
table->model->dividing_row = -1;
// Ensure that the transaction and splits being edited are in the split
// list we're about to load.
if (pending_trans != NULL)
{
for (node = xaccTransGetSplitList(pending_trans); node; node = node->next)
{
Split *pending_split = (Split*)node->data;
if (!xaccTransStillHasSplit(pending_trans, pending_split)) continue;
if (g_list_find(slist, pending_split) != NULL)
continue;
if (g_list_find_custom(slist, pending_trans,
_find_split_with_parent_txn) != NULL)
continue;
if (!we_own_slist)
{
// lazy-copy
slist = g_list_copy(slist);
we_own_slist = TRUE;
}
slist = g_list_append(slist, pending_split);
}
}
if (multi_line)
trans_table = g_hash_table_new (g_direct_hash, g_direct_equal);
/* populate the table */
for (node = slist; node; node = node->next)
{
split = node->data;
trans = xaccSplitGetParent (split);
if (!xaccTransStillHasSplit(trans, split))
continue;
if (pending_trans == trans)
found_pending = TRUE;
/* If the transaction has only one split, and it's not our
* pending_trans, then it's another register's blank split and
* we don't want to see it.
*/
else if (xaccTransCountSplits (trans) < 2)
continue;
/* Do not load splits from the blank transaction. */
if (trans == blank_trans)
continue;
if (multi_line)
{
/* Skip this split if its transaction has already been loaded. */
if (g_hash_table_lookup (trans_table, trans))
continue;
g_hash_table_insert (trans_table, trans, trans);
}
if (info->show_present_divider &&
use_autoreadonly &&
!found_divider_upper)
{
if (xaccTransGetDate (trans) >= autoreadonly_time)
{
table->model->dividing_row_upper = vcell_loc.virt_row;
found_divider_upper = TRUE;
}
else
{
need_divider_upper = TRUE;
}
}
if (info->show_present_divider &&
!found_divider &&
(xaccTransGetDate (trans) > present))
{
table->model->dividing_row = vcell_loc.virt_row;
found_divider = TRUE;
}
/* If this is the first load of the register,
* fill up the quickfill cells. */
if (info->first_pass)
add_quickfill_completions(reg->table->layout, trans, split, has_last_num);
if (trans == find_trans)
new_trans_row = vcell_loc.virt_row;
if (split == find_trans_split)
new_trans_split_row = vcell_loc.virt_row;
gnc_split_register_add_transaction (reg, trans, split,
lead_cursor, split_cursor,
multi_line, start_primary_color,
TRUE,
find_trans, find_split, find_class,
&new_split_row, &vcell_loc);
if (!multi_line)
start_primary_color = !start_primary_color;
}
if (multi_line)
g_hash_table_destroy (trans_table);
/* add the blank split at the end. */
if (pending_trans == blank_trans)
found_pending = TRUE;
/* No upper divider yet? Store it now */
if (info->show_present_divider &&
use_autoreadonly &&
!found_divider_upper && need_divider_upper)
{
table->model->dividing_row_upper = vcell_loc.virt_row;
found_divider_upper = TRUE;
}
if (blank_trans == find_trans)
new_trans_row = vcell_loc.virt_row;
if (blank_split == find_trans_split)
new_trans_split_row = vcell_loc.virt_row;
/* If we didn't find the pending transaction, it was removed
* from the account. */
if (!found_pending)
{
info->pending_trans_guid = *guid_null ();
if (xaccTransIsOpen (pending_trans))
xaccTransCommitEdit (pending_trans);
else if (pending_trans)
g_assert_not_reached();
pending_trans = NULL;
}
/* go to blank on first pass */
if (info->first_pass)
{
new_split_row = -1;
new_trans_split_row = -1;
new_trans_row = -1;
save_loc.vcell_loc = vcell_loc;
save_loc.phys_row_offset = 0;
save_loc.phys_col_offset = 0;
}
gnc_split_register_add_transaction (reg, blank_trans, blank_split,
lead_cursor, split_cursor,
multi_line, start_primary_color,
info->blank_split_edited, find_trans,
find_split, find_class, &new_split_row,
&vcell_loc);
/* resize the table to the sizes we just counted above */
/* num_virt_cols is always one. */
gnc_table_set_size (table, vcell_loc.virt_row, 1);
/* restore the cursor to its rightful position */
{
VirtualLocation trans_split_loc;
if (new_split_row > 0)
save_loc.vcell_loc.virt_row = new_split_row;
else if (new_trans_split_row > 0)
save_loc.vcell_loc.virt_row = new_trans_split_row;
else if (new_trans_row > 0)
save_loc.vcell_loc.virt_row = new_trans_row;
trans_split_loc = save_loc;
gnc_split_register_get_trans_split (reg, save_loc.vcell_loc,
&trans_split_loc.vcell_loc);
if (dynamic || multi_line || info->trans_expanded)
{
gnc_table_set_virt_cell_cursor(
table, trans_split_loc.vcell_loc,
gnc_split_register_get_active_cursor (reg));
gnc_split_register_set_trans_visible (reg, trans_split_loc.vcell_loc,
TRUE, multi_line);
info->trans_expanded = (reg->style == REG_STYLE_LEDGER);
}
else
{
save_loc = trans_split_loc;
info->trans_expanded = FALSE;
}
if (gnc_table_find_close_valid_cell (table, &save_loc, FALSE))
{
gnc_table_move_cursor_gui (table, save_loc);
new_split_row = save_loc.vcell_loc.virt_row;
if (find_split == gnc_split_register_get_current_split (reg))
gnc_table_restore_current_cursor (table, cursor_buffer);
}
gnc_cursor_buffer_destroy (cursor_buffer);
cursor_buffer = NULL;
}
/* Set up the hint transaction, split, transaction split, and column. */
info->cursor_hint_trans = gnc_split_register_get_current_trans (reg);
info->cursor_hint_split = gnc_split_register_get_current_split (reg);
info->cursor_hint_trans_split =
gnc_split_register_get_current_trans_split (reg, NULL);
info->cursor_hint_cursor_class =
gnc_split_register_get_current_cursor_class (reg);
info->hint_set_by_traverse = FALSE;
info->traverse_to_new = FALSE;
info->exact_traversal = FALSE;
info->first_pass = FALSE;
info->reg_loaded = TRUE;
gnc_split_register_set_cell_fractions(
reg, gnc_split_register_get_current_split (reg));
gnc_table_refresh_gui (table, TRUE);
gnc_split_register_show_trans (reg, table->current_cursor_loc.vcell_loc);
/* enable callback for cursor user-driven moves */
gnc_table_control_allow_move (table->control, TRUE);
if (we_own_slist)
g_list_free(slist);
LEAVE(" ");
}
/* XXX This code is a cut-n-paste job from the SplitRegister code;
* the split-register should be generalized to the point where a cut-n-paste
* like this isn't required, and this should be trashed.
*/
void gnc_entry_ledger_load (GncEntryLedger *ledger, GList *entry_list)
{
GncEntry *blank_entry, *find_entry;
CursorBuffer *cursor_buffer;
Table *table;
GList *node;
CellBlock *cursor_header, *cursor;
VirtualCellLocation vcell_loc;
VirtualLocation save_loc;
gboolean start_primary_color = TRUE;
int new_entry_row = -1;
if (!ledger) return;
/* Load up cells */
load_discount_type_cells (ledger);
load_discount_how_cells (ledger);
gnc_entry_ledger_load_xfer_cells (ledger);
blank_entry = gnc_entry_ledger_get_blank_entry (ledger);
if (blank_entry == NULL && ledger->invoice == NULL && entry_list == NULL)
return;
if (blank_entry == NULL && ledger->invoice)
{
switch (ledger->type)
{
case GNCENTRY_ORDER_ENTRY:
case GNCENTRY_INVOICE_ENTRY:
case GNCENTRY_BILL_ENTRY:
case GNCENTRY_EXPVOUCHER_ENTRY:
case GNCENTRY_CUST_CREDIT_NOTE_ENTRY:
case GNCENTRY_VEND_CREDIT_NOTE_ENTRY:
case GNCENTRY_EMPL_CREDIT_NOTE_ENTRY:
gnc_suspend_gui_refresh ();
blank_entry = gncEntryCreate (ledger->book);
gncEntrySetDateGDate (blank_entry, &ledger->last_date_entered);
ledger->blank_entry_guid = *gncEntryGetGUID (blank_entry);
gnc_resume_gui_refresh ();
/* The rest of this does not apply to expense vouchers */
if (ledger->type != GNCENTRY_EXPVOUCHER_ENTRY)
{
const GncOwner *owner = gncOwnerGetEndOwner (gncInvoiceGetOwner (ledger->invoice));
GncTaxTable *table = NULL;
GncTaxIncluded taxincluded_p = GNC_TAXINCLUDED_USEGLOBAL;
gboolean taxincluded = FALSE;
gnc_numeric discount = gnc_numeric_zero ();
gnc_numeric price = gnc_numeric_zero ();
/* Determine the Price from Customer's or Vendor's Job */
switch (gncOwnerGetType (gncInvoiceGetOwner (ledger->invoice)))
{
case GNC_OWNER_JOB:
price = gncJobGetRate( gncOwnerGetJob (gncInvoiceGetOwner (ledger->invoice)));
break;
default:
break;
}
/* Determine the TaxIncluded and Discount values */
switch (gncOwnerGetType (owner))
{
case GNC_OWNER_CUSTOMER:
taxincluded_p = gncCustomerGetTaxIncluded (owner->owner.customer);
discount = gncCustomerGetDiscount (owner->owner.customer);
break;
case GNC_OWNER_VENDOR:
taxincluded_p = gncVendorGetTaxIncluded (owner->owner.vendor);
break;
default:
break;
}
/* Compute the default taxincluded */
switch (taxincluded_p)
{
case GNC_TAXINCLUDED_YES:
taxincluded = TRUE;
break;
case GNC_TAXINCLUDED_NO:
taxincluded = FALSE;
break;
case GNC_TAXINCLUDED_USEGLOBAL:
if (ledger->prefs_group)
{
taxincluded = gnc_prefs_get_bool (ledger->prefs_group, GNC_PREF_TAX_INCL);
}
else
{
taxincluded = FALSE;
}
break;
}
/* Compute the proper taxtable */
switch (gncOwnerGetType (owner))
{
case GNC_OWNER_CUSTOMER:
table = gnc_business_get_default_tax_table (ledger->book,
GNC_OWNER_CUSTOMER);
if (gncCustomerGetTaxTableOverride (owner->owner.customer))
table = gncCustomerGetTaxTable (owner->owner.customer);
break;
case GNC_OWNER_VENDOR:
table = gnc_business_get_default_tax_table (ledger->book,
GNC_OWNER_VENDOR);
if (gncVendorGetTaxTableOverride (owner->owner.vendor))
table = gncVendorGetTaxTable (owner->owner.vendor);
break;
default:
break;
}
if (ledger->is_cust_doc)
{
gncEntrySetInvTaxTable (blank_entry, table);
gncEntrySetInvTaxIncluded (blank_entry, taxincluded);
gncEntrySetInvDiscount (blank_entry, discount);
gncEntrySetInvPrice (blank_entry, price);
}
else
{
gncEntrySetBillTaxTable (blank_entry, table);
gncEntrySetBillTaxIncluded (blank_entry, taxincluded);
gncEntrySetBillPrice (blank_entry, price);
}
}
break;
default:
ledger->blank_entry_guid = *guid_null ();
break;
}
ledger->blank_entry_edited = FALSE;
}
table = ledger->table;
gnc_table_leave_update (table, table->current_cursor_loc);
save_loc = table->current_cursor_loc;
/* Figure out where we are going to */
if (ledger->traverse_to_new)
{
find_entry = blank_entry;
}
else if (ledger->hint_entry)
{
find_entry = ledger->hint_entry;
}
else
{
find_entry = gnc_entry_ledger_get_current_entry(ledger);
/* XXX: get current entry (cursor_hint_xxx) */
}
/* If the current cursor has changed we save the values for later
* possible restoration. */
if (gnc_table_current_cursor_changed (table, TRUE) &&
(find_entry == gnc_entry_ledger_get_current_entry (ledger)))
{
cursor_buffer = gnc_cursor_buffer_new ();
gnc_table_save_current_cursor (table, cursor_buffer);
}
else
cursor_buffer = NULL;
/* disable move callback -- we don't want the cascade of
* callbacks while we are fiddling with loading the register */
gnc_table_control_allow_move (table->control, FALSE);
/* invalidate the cursor */
{
VirtualLocation virt_loc;
virt_loc.vcell_loc.virt_row = -1;
virt_loc.vcell_loc.virt_col = -1;
virt_loc.phys_row_offset = -1;
virt_loc.phys_col_offset = -1;
gnc_table_move_cursor_gui (table, virt_loc);
}
/* make sure that the header is loaded */
vcell_loc.virt_row = 0;
vcell_loc.virt_col = 0;
cursor_header = gnc_table_layout_get_cursor (table->layout, CURSOR_HEADER);
gnc_table_set_vcell (table, cursor_header, NULL, TRUE, TRUE, vcell_loc);
vcell_loc.virt_row++;
/* get the current time and reset the dividing row */
table->model->dividing_row_upper = -1;
table->model->dividing_row = -1;
table->model->dividing_row_lower = -1;
cursor = gnc_table_layout_get_cursor (table->layout, "cursor");
/* Populate the table */
for (node = entry_list; node; node = node->next)
{
GncEntry *entry = node->data;
/* Don't load the blank entry */
if (entry == blank_entry)
continue;
/* If this is the first load of the ledger, fill the quickfill cells */
{
/* XXX */
}
if (entry == find_entry)
new_entry_row = vcell_loc.virt_row;
gnc_table_set_vcell (table, cursor, gncEntryGetGUID (entry),
TRUE, start_primary_color, vcell_loc);
vcell_loc.virt_row++;
/* Flip color for the next guy */
start_primary_color = !start_primary_color;
}
/* Add the blank entry at the end. */
if (blank_entry)
{
gnc_table_set_vcell (table, cursor, gncEntryGetGUID (blank_entry),
TRUE, start_primary_color, vcell_loc);
if (find_entry == blank_entry)
new_entry_row = vcell_loc.virt_row;
vcell_loc.virt_row++;
}
/* Resize the table */
gnc_table_set_size (table, vcell_loc.virt_row, 1);
/* Restore the cursor to its rightful position */
if (new_entry_row > 0)
save_loc.vcell_loc.virt_row = new_entry_row;
if (gnc_table_find_close_valid_cell (table, &save_loc, FALSE))
{
gnc_table_move_cursor_gui (table, save_loc);
if (find_entry == gnc_entry_ledger_get_current_entry (ledger))
gnc_table_restore_current_cursor (table, cursor_buffer);
}
gnc_cursor_buffer_destroy (cursor_buffer);
cursor_buffer = NULL;
/* Reset the ledger */
ledger->traverse_to_new = FALSE;
ledger->hint_entry = NULL;
/* Set the cell fractions */
gnc_table_refresh_gui (table, TRUE);
gnc_entry_ledger_show_entry (ledger, table->current_cursor_loc.vcell_loc);
/* Set completion character */
gnc_combo_cell_set_complete_char
((ComboCell *)
gnc_table_layout_get_cell (table->layout, ENTRY_IACCT_CELL),
gnc_get_account_separator ());
gnc_combo_cell_set_complete_char
((ComboCell *)
gnc_table_layout_get_cell (table->layout, ENTRY_BACCT_CELL),
gnc_get_account_separator ());
/* enable callback for cursor user-driven moves */
gnc_table_control_allow_move (table->control, TRUE);
}
static void
gnc_gui_refresh_internal (gboolean force)
{
GList *list;
GList *node;
if (!got_events && !force)
return;
gnc_suspend_gui_refresh ();
{
GHashTable *table;
table = changes_backup.event_masks;
changes_backup.event_masks = changes.event_masks;
changes.event_masks = table;
table = changes_backup.entity_events;
changes_backup.entity_events = changes.entity_events;
changes.entity_events = table;
}
#if CM_DEBUG
fprintf (stderr, "%srefresh!\n", force ? "forced " : "");
#endif
list = find_component_ids_by_class (NULL);
for (node = list; node; node = node->next)
{
ComponentInfo *ci = find_component (GPOINTER_TO_INT (node->data));
if (!ci)
continue;
if (!ci->refresh_handler)
{
#if CM_DEBUG
fprintf (stderr, "no handlers for %s:%d\n", ci->component_class, ci->component_id);
#endif
continue;
}
if (force)
{
if (ci->refresh_handler)
{
#if CM_DEBUG
fprintf (stderr, "calling %s:%d C handler\n", ci->component_class, ci->component_id);
#endif
ci->refresh_handler (NULL, ci->user_data);
}
}
else if (changes_match (&ci->watch_info, &changes_backup))
{
if (ci->refresh_handler)
{
#if CM_DEBUG
fprintf (stderr, "calling %s:%d C handler\n", ci->component_class, ci->component_id);
#endif
ci->refresh_handler (changes_backup.entity_events, ci->user_data);
}
}
else
{
#if CM_DEBUG
fprintf (stderr, "no match for %s:%d\n", ci->component_class, ci->component_id);
#endif
}
}
clear_event_info (&changes_backup);
got_events = FALSE;
g_list_free (list);
gnc_resume_gui_refresh ();
}
