gboolean
gnc_stock_split_assistant_details_complete (GtkAssistant *assistant,
gpointer user_data)
{
StockSplitInfo *info = user_data;
gnc_numeric amount;
gint result;
result = gnc_amount_edit_expr_is_valid (GNC_AMOUNT_EDIT (info->distribution_edit), &amount, TRUE);
if ( result != 0)
return FALSE; /* Parsing error or field is empty */
if (gnc_numeric_zero_p (amount))
return FALSE; /* field value is 0 */
result = gnc_amount_edit_expr_is_valid (GNC_AMOUNT_EDIT (info->price_edit), &amount, TRUE);
if (result == -1)
return TRUE; /* Optional field is empty */
else if ( result > 0)
return FALSE; /* Parsing error */
else if (gnc_numeric_negative_p (amount))
return FALSE; /* Negative price is not allowed */
else
return TRUE; /* Valid positive price */
}
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 ();
}
/* Copy the values in the financial_info structure to the GUI */
static void
fi_to_gui(FinCalcDialog *fcd)
{
const gnc_commodity *commodity;
static char string[64];
gnc_numeric total;
gnc_numeric npp;
gnc_numeric pmt;
int i;
if (fcd == NULL)
return;
npp = gnc_numeric_create (fcd->financial_info.npp, 1);
gnc_amount_edit_set_amount (GNC_AMOUNT_EDIT(fcd->amounts[PAYMENT_PERIODS]),
npp);
gnc_amount_edit_set_damount (GNC_AMOUNT_EDIT(fcd->amounts[INTEREST_RATE]),
fcd->financial_info.ir);
gnc_amount_edit_set_damount (GNC_AMOUNT_EDIT(fcd->amounts[PRESENT_VALUE]),
fcd->financial_info.pv);
gnc_amount_edit_set_damount (GNC_AMOUNT_EDIT(fcd->amounts[PERIODIC_PAYMENT]),
fcd->financial_info.pmt);
gnc_amount_edit_set_damount (GNC_AMOUNT_EDIT(fcd->amounts[FUTURE_VALUE]),
-fcd->financial_info.fv);
pmt = double_to_gnc_numeric (fcd->financial_info.pmt, 100000, GNC_HOW_RND_ROUND_HALF_UP);
commodity = gnc_default_currency ();
total = gnc_numeric_mul (npp, pmt, gnc_commodity_get_fraction (commodity),
GNC_HOW_RND_ROUND_HALF_UP);
xaccSPrintAmount (string, total, gnc_default_print_info (FALSE));
gtk_label_set_text (GTK_LABEL(fcd->payment_total_label), string);
i = normalize_period(&fcd->financial_info.CF);
gtk_combo_box_set_active(GTK_COMBO_BOX(fcd->compounding_combo), i);
i = normalize_period(&fcd->financial_info.PF);
gtk_combo_box_set_active(GTK_COMBO_BOX(fcd->payment_combo), i);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(fcd->end_of_period_radio),
!fcd->financial_info.bep);
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON(fcd->discrete_compounding_radio),
fcd->financial_info.disc);
}
gboolean
gnc_stock_split_assistant_cash_complete (GtkAssistant *assistant,
gpointer user_data)
{
StockSplitInfo *info = user_data;
gnc_numeric amount;
gint result;
Account *account;
result = gnc_amount_edit_expr_is_valid (GNC_AMOUNT_EDIT (info->cash_edit), &amount, TRUE);
if (result == -1)
return TRUE; /* Optional field is empty */
else if ( result > 0)
return FALSE; /* Parsing error */
else if (gnc_numeric_negative_p (amount))
return FALSE; /* Negative cash amount is not allowed */
/* We have a positive cash amount */
account = gnc_tree_view_account_get_selected_account (GNC_TREE_VIEW_ACCOUNT(info->income_tree));
if (!account)
return FALSE;
account = gnc_tree_view_account_get_selected_account (GNC_TREE_VIEW_ACCOUNT(info->asset_tree));
if (!account)
return FALSE;
return TRUE;
}
static void
refresh_details_page (StockSplitInfo *info)
{
GNCPrintAmountInfo print_info;
gnc_commodity *commodity, *currency;
Account *account;
QofBook *book;
GNCPriceDB *db;
GList *prices;
account = info->acct;
g_return_if_fail (account != NULL);
print_info = gnc_account_print_info (account, FALSE);
gnc_amount_edit_set_print_info (GNC_AMOUNT_EDIT (info->distribution_edit),
print_info);
gnc_amount_edit_set_fraction (GNC_AMOUNT_EDIT (info->distribution_edit),
xaccAccountGetCommoditySCU (account));
commodity = xaccAccountGetCommodity (account);
book = gnc_account_get_book (account);
db = gnc_pricedb_get_db(book);
prices = gnc_pricedb_lookup_latest_any_currency(db, commodity);
if (prices)
{
/* Use the first existing price */
if (gnc_commodity_equiv (commodity, gnc_price_get_currency(prices->data)))
currency = gnc_price_get_commodity(prices->data);
else
currency = gnc_price_get_currency(prices->data);
}
else
{
/* Take a wild guess. */
currency = gnc_default_currency ();
}
gnc_price_list_destroy(prices);
gnc_currency_edit_set_currency
(GNC_CURRENCY_EDIT (info->price_currency_edit),
currency);
}
/* Copy the values in the GUI to the financial_info structure */
static void
gui_to_fi(FinCalcDialog *fcd)
{
GtkToggleButton *toggle;
gnc_numeric npp;
int i;
if (fcd == NULL)
return;
npp =
gnc_amount_edit_get_amount(GNC_AMOUNT_EDIT(fcd->amounts[PAYMENT_PERIODS]));
fcd->financial_info.npp = npp.num;
fcd->financial_info.ir =
gnc_amount_edit_get_damount(GNC_AMOUNT_EDIT(fcd->amounts[INTEREST_RATE]));
fcd->financial_info.pv =
gnc_amount_edit_get_damount(GNC_AMOUNT_EDIT(fcd->amounts[PRESENT_VALUE]));
fcd->financial_info.pmt =
gnc_amount_edit_get_damount(GNC_AMOUNT_EDIT(fcd->amounts[PERIODIC_PAYMENT]));
fcd->financial_info.fv =
gnc_amount_edit_get_damount(GNC_AMOUNT_EDIT(fcd->amounts[FUTURE_VALUE]));
fcd->financial_info.fv = -fcd->financial_info.fv;
i = gtk_combo_box_get_active(GTK_COMBO_BOX(fcd->compounding_combo));
fcd->financial_info.CF = periods[i];
i = gtk_combo_box_get_active(GTK_COMBO_BOX(fcd->payment_combo));
fcd->financial_info.PF = periods[i];
toggle = GTK_TOGGLE_BUTTON(fcd->end_of_period_radio);
fcd->financial_info.bep = !gtk_toggle_button_get_active(toggle);
toggle = GTK_TOGGLE_BUTTON(fcd->discrete_compounding_radio);
fcd->financial_info.disc = gtk_toggle_button_get_active(toggle);
fcd->financial_info.prec = gnc_locale_decimal_places ();
}
void gnc_ui_payment_window_set_amount (PaymentWindow *pw, gnc_numeric amount)
{
g_assert(pw);
/* Debits are negative, credits are positive */
if (gnc_numeric_positive_p (amount))
{
gnc_amount_edit_set_amount (GNC_AMOUNT_EDIT(pw->amount_credit_edit),
amount);
gnc_amount_edit_set_amount (GNC_AMOUNT_EDIT(pw->amount_debit_edit),
gnc_numeric_zero ());
}
else
{
gnc_amount_edit_set_amount (GNC_AMOUNT_EDIT(pw->amount_debit_edit),
gnc_numeric_neg (amount));
gnc_amount_edit_set_amount (GNC_AMOUNT_EDIT(pw->amount_credit_edit),
gnc_numeric_zero ());
}
}
void
gnc_payment_leave_amount_cb (GtkWidget *widget, GdkEventFocus *event,
PaymentWindow *pw)
{
gnc_numeric amount_deb, amount_cred, amount_tot;
if (! pw->amount_credit_edit || ! pw->amount_debit_edit)
return;
/* If both credit and debit amount are entered, simplify it to either one */
amount_deb = gnc_amount_edit_get_amount (GNC_AMOUNT_EDIT (pw->amount_debit_edit));
amount_cred = gnc_amount_edit_get_amount (GNC_AMOUNT_EDIT (pw->amount_credit_edit));
amount_tot = gnc_numeric_sub (amount_cred, amount_deb,
gnc_commodity_get_fraction (xaccAccountGetCommodity (pw->post_acct)),
GNC_HOW_RND_ROUND_HALF_UP);
gnc_ui_payment_window_set_amount (pw, amount_tot);
/* Reflect if the payment could complete now */
gnc_payment_window_check_payment (pw);
}
/**
* Create a new AB_TRANSACTION, fill the values from the entry fields into it
* and return it. The caller must AB_TRANSACTION_free() it when finished.
*/
static AB_TRANSACTION *
ab_trans_fill_values(GncABTransDialog *td)
{
/* Fill in the user-entered values */
AB_TRANSACTION *trans = AB_Transaction_new();
AB_VALUE *value;
AB_Transaction_SetLocalBankCode(trans, AB_Account_GetBankCode(td->ab_acc));
AB_Transaction_SetLocalAccountNumber(
trans, AB_Account_GetAccountNumber(td->ab_acc));
AB_Transaction_SetLocalCountry(trans, "DE");
AB_Transaction_SetRemoteBankCode(
trans, gtk_entry_get_text(GTK_ENTRY(td->recp_bankcode_entry)));
AB_Transaction_SetRemoteAccountNumber(
trans, gtk_entry_get_text(GTK_ENTRY(td->recp_account_entry)));
AB_Transaction_SetRemoteCountry(trans, "DE");
AB_Transaction_AddRemoteName(
trans, gtk_entry_get_text(GTK_ENTRY(td->recp_name_entry)), FALSE);
AB_Transaction_AddPurpose(
trans, gtk_entry_get_text(GTK_ENTRY(td->purpose_entry)), FALSE);
AB_Transaction_AddPurpose(
trans, gtk_entry_get_text(GTK_ENTRY(td->purpose_cont_entry)), FALSE);
AB_Transaction_AddPurpose(
trans, gtk_entry_get_text(GTK_ENTRY(td->purpose_cont2_entry)), FALSE);
AB_Transaction_AddPurpose(
trans, gtk_entry_get_text(GTK_ENTRY(td->purpose_cont3_entry)), FALSE);
value = AB_Value_fromDouble(gnc_amount_edit_get_damount(
GNC_AMOUNT_EDIT(td->amount_edit)));
/* FIXME: Replace "EUR" by account-dependent string here. */
AB_Value_SetCurrency(value, "EUR");
AB_Transaction_SetValue(trans, value);
AB_Value_free(value);
/* If this is a direct debit, a textkey/ "Textschluessel"/transactionCode
* different from the default has to be set. */
switch (td->trans_type)
{
case SINGLE_DEBITNOTE:
/* AB_Transaction_SetTransactionCode (trans, 05); */
AB_Transaction_SetTextKey(trans, 05);
break;
default:
/* AB_Transaction_SetTransactionCode (trans, 51); */
AB_Transaction_SetTextKey (trans, 51);
break;
}
return trans;
}
static gboolean check_edit_amount (GtkWidget *dialog, GtkWidget *amount,
gnc_numeric *min, gnc_numeric *max,
const char * error_message)
{
if (!gnc_amount_edit_evaluate (GNC_AMOUNT_EDIT (amount)))
{
if (error_message)
gnc_error_dialog (dialog, "%s", error_message);
return TRUE;
}
/* We've got a valid-looking number; check mix/max */
if (min || max)
{
gnc_numeric val = gnc_amount_edit_get_amount (GNC_AMOUNT_EDIT (amount));
if ((min && gnc_numeric_compare (*min, val) > 0) ||
(max && gnc_numeric_compare (val, *max) > 0))
{
if (error_message)
gnc_error_dialog (dialog, "%s", error_message);
return TRUE;
}
}
return FALSE;
}
/********************************************************************\
* autoClearWindow *
* opens up the window to auto-clear an account *
* *
* Args: parent - the parent of this window *
* account - the account to auto-clear *
* Return: autoClearData - the instance of this AutoClearWindow *
\********************************************************************/
AutoClearWindow *
autoClearWindow (GtkWidget *parent, Account *account)
{
GtkBox *box;
GtkLabel *label;
GtkBuilder *builder;
AutoClearWindow *data;
char *title;
data = g_new0 (AutoClearWindow, 1);
data->account = account;
/* Create the dialog box */
builder = gtk_builder_new();
gnc_builder_add_from_file (builder, "window-autoclear.glade", "auto_clear_start_dialog");
data->window = GTK_WIDGET(gtk_builder_get_object (builder, "auto_clear_start_dialog"));
title = gnc_autoclear_make_window_name (account);
gtk_window_set_title(GTK_WINDOW(data->window), title);
g_free (title);
// Set the style context for this dialog so it can be easily manipulated with css
gnc_widget_set_style_context (GTK_WIDGET(data->window), "GncAutoClearDialog");
/* Add amount edit box */
data->end_value = GNC_AMOUNT_EDIT(gnc_amount_edit_new());
g_signal_connect(GTK_WIDGET(data->end_value), "activate",
G_CALLBACK(gnc_autoclear_window_ok_cb), data);
box = GTK_BOX(gtk_builder_get_object (builder, "end_value_box"));
gtk_box_pack_start(box, GTK_WIDGET(data->end_value), TRUE, TRUE, 0);
label = GTK_LABEL(gtk_builder_get_object (builder, "end_label"));
gtk_label_set_mnemonic_widget(label, GTK_WIDGET(data->end_value));
gtk_widget_grab_focus(GTK_WIDGET(data->end_value));
data->status_label = GTK_LABEL(gtk_builder_get_object (builder, "status_label"));
if (parent != NULL)
gtk_window_set_transient_for (GTK_WINDOW (data->window), GTK_WINDOW (parent));
gtk_builder_connect_signals(builder, data);
g_object_unref(G_OBJECT(builder));
return data;
}
/********************************************************************\
* autoClearWindow *
* opens up the window to auto-clear an account *
* *
* Args: parent - the parent of this window *
* account - the account to auto-clear *
* Return: autoClearData - the instance of this AutoClearWindow *
\********************************************************************/
AutoClearWindow *
autoClearWindow (GtkWidget *parent, Account *account)
{
GtkWidget *dialog, *box, *label, *end_value;
GladeXML *xml;
AutoClearWindow *data;
char *title;
data = g_new0 (AutoClearWindow, 1);
data->account = account;
/* Create the dialog box */
xml = gnc_glade_xml_new ("autoclear.glade", "Auto-clear Start Dialog");
dialog = glade_xml_get_widget (xml, "Auto-clear Start Dialog");
title = gnc_autoclear_make_window_name (account);
gtk_window_set_title(GTK_WINDOW(dialog), title);
g_free (title);
/* Add amount edit box */
end_value = gnc_amount_edit_new();
data->end_value = GNC_AMOUNT_EDIT(end_value);
box = glade_xml_get_widget(xml, "end_value_box");
gtk_box_pack_start(GTK_BOX(box), end_value, TRUE, TRUE, 0);
label = glade_xml_get_widget(xml, "end_label");
gtk_label_set_mnemonic_widget(GTK_LABEL(label), end_value);
gtk_widget_grab_focus(GTK_WIDGET(end_value));
data->window = GTK_WIDGET(dialog);
if (parent != NULL)
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (parent));
data->ok_button = glade_xml_get_widget(xml, "ok_button");
data->cancel_button = glade_xml_get_widget(xml, "cancel_button");
data->status_label = GTK_LABEL(glade_xml_get_widget(xml, "status_label"));
g_signal_connect(data->ok_button, "clicked",
G_CALLBACK(gnc_autoclear_window_ok_cb), data);
g_signal_connect(data->end_value, "activate",
G_CALLBACK(gnc_autoclear_window_ok_cb), data);
g_signal_connect(data->cancel_button, "clicked",
G_CALLBACK(gnc_autoclear_window_cancel_cb), data);
return data;
}
static EmployeeWindow *
gnc_employee_new_window (QofBook *bookp,
GncEmployee *employee)
{
EmployeeWindow *ew;
GtkBuilder *builder;
GtkWidget *hbox, *edit;
gnc_commodity *currency;
GNCPrintAmountInfo print_info;
GList *acct_types;
Account *ccard_acct;
/*
* Find an existing window for this employee. If found, bring it to
* the front.
*/
if (employee)
{
GncGUID employee_guid;
employee_guid = *gncEmployeeGetGUID (employee);
ew = gnc_find_first_gui_component (DIALOG_EDIT_EMPLOYEE_CM_CLASS,
find_handler, &employee_guid);
if (ew)
{
gtk_window_present (GTK_WINDOW(ew->dialog));
return(ew);
}
}
/* Find the default currency */
if (employee)
currency = gncEmployeeGetCurrency (employee);
else
currency = gnc_default_currency ();
/*
* No existing employee window found. Build a new one.
*/
ew = g_new0 (EmployeeWindow, 1);
ew->book = bookp;
/* Find the dialog */
builder = gtk_builder_new();
gnc_builder_add_from_file (builder, "dialog-employee.glade", "Employee Dialog");
ew->dialog = GTK_WIDGET(gtk_builder_get_object (builder, "Employee Dialog"));
g_object_set_data (G_OBJECT (ew->dialog), "dialog_info", ew);
/* Get entry points */
ew->id_entry = GTK_WIDGET(gtk_builder_get_object (builder, "id_entry"));
ew->username_entry = GTK_WIDGET(gtk_builder_get_object (builder, "username_entry"));
ew->name_entry = GTK_WIDGET(gtk_builder_get_object (builder, "name_entry"));
ew->addr1_entry = GTK_WIDGET(gtk_builder_get_object (builder, "addr1_entry"));
ew->addr2_entry = GTK_WIDGET(gtk_builder_get_object (builder, "addr2_entry"));
ew->addr3_entry = GTK_WIDGET(gtk_builder_get_object (builder, "addr3_entry"));
ew->addr4_entry = GTK_WIDGET(gtk_builder_get_object (builder, "addr4_entry"));
ew->phone_entry = GTK_WIDGET(gtk_builder_get_object (builder, "phone_entry"));
ew->fax_entry = GTK_WIDGET(gtk_builder_get_object (builder, "fax_entry"));
ew->email_entry = GTK_WIDGET(gtk_builder_get_object (builder, "email_entry"));
ew->language_entry = GTK_WIDGET(gtk_builder_get_object (builder, "language_entry"));
ew->active_check = GTK_WIDGET(gtk_builder_get_object (builder, "active_check"));
/* Currency */
edit = gnc_currency_edit_new();
gnc_currency_edit_set_currency (GNC_CURRENCY_EDIT(edit), currency);
ew->currency_edit = edit;
hbox = GTK_WIDGET(gtk_builder_get_object (builder, "currency_box"));
gtk_box_pack_start (GTK_BOX (hbox), edit, TRUE, TRUE, 0);
/* WORKDAY: Value */
edit = gnc_amount_edit_new();
gnc_amount_edit_set_evaluate_on_enter (GNC_AMOUNT_EDIT (edit), TRUE);
print_info = gnc_integral_print_info ();
print_info.max_decimal_places = 5;
gnc_amount_edit_set_print_info (GNC_AMOUNT_EDIT (edit), print_info);
gnc_amount_edit_set_fraction (GNC_AMOUNT_EDIT (edit), 100000);
ew->workday_amount = edit;
gtk_widget_show (edit);
hbox = GTK_WIDGET(gtk_builder_get_object (builder, "hours_hbox"));
gtk_box_pack_start (GTK_BOX (hbox), edit, TRUE, TRUE, 0);
/* RATE: Monetary Value */
edit = gnc_amount_edit_new();
print_info = gnc_commodity_print_info (currency, FALSE);
gnc_amount_edit_set_evaluate_on_enter (GNC_AMOUNT_EDIT (edit), TRUE);
gnc_amount_edit_set_print_info (GNC_AMOUNT_EDIT (edit), print_info);
gnc_amount_edit_set_fraction (GNC_AMOUNT_EDIT (edit),
gnc_commodity_get_fraction (currency));
ew->rate_amount = edit;
gtk_widget_show (edit);
hbox = GTK_WIDGET(gtk_builder_get_object (builder, "rate_hbox"));
gtk_box_pack_start (GTK_BOX (hbox), edit, TRUE, TRUE, 0);
/* CCard Account Selection */
ew->ccard_acct_check = GTK_WIDGET(gtk_builder_get_object (builder, "ccard_check"));
edit = gnc_account_sel_new();
acct_types = g_list_prepend(NULL, (gpointer)ACCT_TYPE_CREDIT);
gnc_account_sel_set_acct_filters (GNC_ACCOUNT_SEL(edit), acct_types, NULL);
g_list_free (acct_types);
ew->ccard_acct_sel = edit;
gtk_widget_show (edit);
hbox = GTK_WIDGET(gtk_builder_get_object (builder, "ccard_acct_hbox"));
gtk_box_pack_start (GTK_BOX (hbox), edit, TRUE, TRUE, 0);
/* Setup signals */
gtk_builder_connect_signals_full (builder, gnc_builder_connect_full_func, ew);
/* Setup initial values */
if (employee != NULL)
{
GncAddress *addr;
ew->dialog_type = EDIT_EMPLOYEE;
ew->employee_guid = *gncEmployeeGetGUID (employee);
addr = gncEmployeeGetAddr (employee);
gtk_entry_set_text (GTK_ENTRY (ew->id_entry), gncEmployeeGetID (employee));
gtk_entry_set_text (GTK_ENTRY (ew->username_entry), gncEmployeeGetUsername (employee));
/* Setup Address */
gtk_entry_set_text (GTK_ENTRY (ew->name_entry), gncAddressGetName (addr));
gtk_entry_set_text (GTK_ENTRY (ew->addr1_entry), gncAddressGetAddr1 (addr));
gtk_entry_set_text (GTK_ENTRY (ew->addr2_entry), gncAddressGetAddr2 (addr));
gtk_entry_set_text (GTK_ENTRY (ew->addr3_entry), gncAddressGetAddr3 (addr));
gtk_entry_set_text (GTK_ENTRY (ew->addr4_entry), gncAddressGetAddr4 (addr));
gtk_entry_set_text (GTK_ENTRY (ew->phone_entry), gncAddressGetPhone (addr));
gtk_entry_set_text (GTK_ENTRY (ew->fax_entry), gncAddressGetFax (addr));
gtk_entry_set_text (GTK_ENTRY (ew->email_entry), gncAddressGetEmail (addr));
gtk_entry_set_text (GTK_ENTRY (ew->language_entry),
gncEmployeeGetLanguage (employee));
/* Set toggle buttons */
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ew->active_check),
gncEmployeeGetActive (employee));
ew->component_id =
gnc_register_gui_component (DIALOG_EDIT_EMPLOYEE_CM_CLASS,
gnc_employee_window_refresh_handler,
gnc_employee_window_close_handler,
ew);
}
else
{
employee = gncEmployeeCreate (bookp);
ew->employee_guid = *gncEmployeeGetGUID (employee);
ew->dialog_type = NEW_EMPLOYEE;
ew->component_id =
gnc_register_gui_component (DIALOG_NEW_EMPLOYEE_CM_CLASS,
gnc_employee_window_refresh_handler,
gnc_employee_window_close_handler,
ew);
}
/* I know that employee exists here -- either passed in or just created */
/* Set the workday and rate values */
gnc_amount_edit_set_amount (GNC_AMOUNT_EDIT (ew->workday_amount),
gncEmployeeGetWorkday (employee));
gnc_amount_edit_set_amount (GNC_AMOUNT_EDIT (ew->rate_amount),
gncEmployeeGetRate (employee));
ccard_acct = gncEmployeeGetCCard (employee);
if (ccard_acct == NULL)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ew->ccard_acct_check), FALSE);
gtk_widget_set_sensitive (ew->ccard_acct_sel, FALSE);
}
else
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ew->ccard_acct_check), TRUE);
gnc_account_sel_set_account (GNC_ACCOUNT_SEL (ew->ccard_acct_sel), ccard_acct, FALSE);
}
/* XXX: Set the ACL */
gnc_gui_component_watch_entity_type (ew->component_id,
GNC_EMPLOYEE_MODULE_NAME,
QOF_EVENT_MODIFY | QOF_EVENT_DESTROY);
gtk_widget_show_all (ew->dialog);
if (ccard_acct == NULL)
gtk_widget_hide (ew->ccard_acct_sel);
g_object_unref(G_OBJECT(builder));
return ew;
}
static CustomerWindow *
gnc_customer_new_window (QofBook *bookp, GncCustomer *cust)
{
CustomerWindow *cw;
GtkBuilder *builder;
GtkWidget *hbox, *edit;
gnc_commodity *currency;
GNCPrintAmountInfo print_info;
/*
* Find an existing window for this customer. If found, bring it to
* the front.
*/
if (cust)
{
GncGUID customer_guid;
customer_guid = *gncCustomerGetGUID(cust);
cw = gnc_find_first_gui_component (DIALOG_EDIT_CUSTOMER_CM_CLASS,
find_handler, &customer_guid);
if (cw)
{
gtk_window_present (GTK_WINDOW(cw->dialog));
return(cw);
}
}
/* Find the default currency */
if (cust)
currency = gncCustomerGetCurrency (cust);
else
currency = gnc_default_currency ();
/*
* No existing customer window found. Build a new one.
*/
cw = g_new0 (CustomerWindow, 1);
cw->book = bookp;
/* Find the dialog */
builder = gtk_builder_new();
gnc_builder_add_from_file (builder, "dialog-customer.glade", "terms_store");
gnc_builder_add_from_file (builder, "dialog-customer.glade", "tax_included_store");
gnc_builder_add_from_file (builder, "dialog-customer.glade", "taxtable_store");
gnc_builder_add_from_file (builder, "dialog-customer.glade", "Customer Dialog");
cw->dialog = GTK_WIDGET (gtk_builder_get_object (builder, "Customer Dialog"));
g_object_set_data (G_OBJECT (cw->dialog), "dialog_info", cw);
/* Get entry points */
cw->id_entry = GTK_WIDGET (gtk_builder_get_object (builder, "id_entry"));
cw->company_entry = GTK_WIDGET (gtk_builder_get_object (builder, "company_entry"));
cw->name_entry = GTK_WIDGET (gtk_builder_get_object (builder, "name_entry"));
cw->addr1_entry = GTK_WIDGET (gtk_builder_get_object (builder, "addr1_entry"));
cw->addr2_entry = GTK_WIDGET (gtk_builder_get_object (builder, "addr2_entry"));
cw->addr3_entry = GTK_WIDGET (gtk_builder_get_object (builder, "addr3_entry"));
cw->addr4_entry = GTK_WIDGET (gtk_builder_get_object (builder, "addr4_entry"));
cw->phone_entry = GTK_WIDGET (gtk_builder_get_object (builder, "phone_entry"));
cw->fax_entry = GTK_WIDGET (gtk_builder_get_object (builder, "fax_entry"));
cw->email_entry = GTK_WIDGET (gtk_builder_get_object (builder, "email_entry"));
cw->shipname_entry = GTK_WIDGET (gtk_builder_get_object (builder, "shipname_entry"));
cw->shipaddr1_entry = GTK_WIDGET (gtk_builder_get_object (builder, "shipaddr1_entry"));
cw->shipaddr2_entry = GTK_WIDGET (gtk_builder_get_object (builder, "shipaddr2_entry"));
cw->shipaddr3_entry = GTK_WIDGET (gtk_builder_get_object (builder, "shipaddr3_entry"));
cw->shipaddr4_entry = GTK_WIDGET (gtk_builder_get_object (builder, "shipaddr4_entry"));
cw->shipphone_entry = GTK_WIDGET (gtk_builder_get_object (builder, "shipphone_entry"));
cw->shipfax_entry = GTK_WIDGET (gtk_builder_get_object (builder, "shipfax_entry"));
cw->shipemail_entry = GTK_WIDGET (gtk_builder_get_object (builder, "shipemail_entry"));
cw->active_check = GTK_WIDGET (gtk_builder_get_object (builder, "active_check"));
cw->taxincluded_menu = GTK_WIDGET (gtk_builder_get_object (builder, "tax_included_menu"));
cw->notes_text = GTK_WIDGET (gtk_builder_get_object (builder, "notes_text"));
cw->terms_menu = GTK_WIDGET (gtk_builder_get_object (builder, "terms_menu"));
cw->taxtable_check = GTK_WIDGET (gtk_builder_get_object (builder, "taxtable_button"));
cw->taxtable_menu = GTK_WIDGET (gtk_builder_get_object (builder, "taxtable_menu"));
/* Currency */
edit = gnc_currency_edit_new();
gnc_currency_edit_set_currency (GNC_CURRENCY_EDIT(edit), currency);
cw->currency_edit = edit;
hbox = GTK_WIDGET (gtk_builder_get_object (builder, "currency_box"));
gtk_box_pack_start (GTK_BOX (hbox), edit, TRUE, TRUE, 0);
/* DISCOUNT: Percentage Value */
edit = gnc_amount_edit_new();
gnc_amount_edit_set_evaluate_on_enter (GNC_AMOUNT_EDIT (edit), TRUE);
print_info = gnc_integral_print_info ();
print_info.max_decimal_places = 5;
gnc_amount_edit_set_print_info (GNC_AMOUNT_EDIT (edit), print_info);
gnc_amount_edit_set_fraction (GNC_AMOUNT_EDIT (edit), 100000);
cw->discount_amount = edit;
gtk_widget_show (edit);
hbox = GTK_WIDGET (gtk_builder_get_object (builder, "discount_box"));
gtk_box_pack_start (GTK_BOX (hbox), edit, TRUE, TRUE, 0);
/* CREDIT: Monetary Value */
edit = gnc_amount_edit_new();
print_info = gnc_commodity_print_info (currency, FALSE);
gnc_amount_edit_set_evaluate_on_enter (GNC_AMOUNT_EDIT (edit), TRUE);
gnc_amount_edit_set_print_info (GNC_AMOUNT_EDIT (edit), print_info);
gnc_amount_edit_set_fraction (GNC_AMOUNT_EDIT (edit),
gnc_commodity_get_fraction (currency));
cw->credit_amount = edit;
gtk_widget_show (edit);
hbox = GTK_WIDGET (gtk_builder_get_object (builder, "credit_box"));
gtk_box_pack_start (GTK_BOX (hbox), edit, TRUE, TRUE, 0);
/* Setup signals */
gtk_builder_connect_signals_full( builder,
gnc_builder_connect_full_func,
cw);
/* Setup initial values */
if (cust != NULL)
{
GtkTextBuffer* text_buffer;
GncAddress *addr, *shipaddr;
const char *string;
cw->dialog_type = EDIT_CUSTOMER;
cw->customer_guid = *gncCustomerGetGUID (cust);
addr = gncCustomerGetAddr (cust);
shipaddr = gncCustomerGetShipAddr (cust);
gtk_entry_set_text (GTK_ENTRY (cw->id_entry), gncCustomerGetID (cust));
gtk_entry_set_text (GTK_ENTRY (cw->company_entry), gncCustomerGetName (cust));
/* Setup Address */
gtk_entry_set_text (GTK_ENTRY (cw->name_entry), gncAddressGetName (addr));
gtk_entry_set_text (GTK_ENTRY (cw->addr1_entry), gncAddressGetAddr1 (addr));
gtk_entry_set_text (GTK_ENTRY (cw->addr2_entry), gncAddressGetAddr2 (addr));
gtk_entry_set_text (GTK_ENTRY (cw->addr3_entry), gncAddressGetAddr3 (addr));
gtk_entry_set_text (GTK_ENTRY (cw->addr4_entry), gncAddressGetAddr4 (addr));
gtk_entry_set_text (GTK_ENTRY (cw->phone_entry), gncAddressGetPhone (addr));
gtk_entry_set_text (GTK_ENTRY (cw->fax_entry), gncAddressGetFax (addr));
gtk_entry_set_text (GTK_ENTRY (cw->email_entry), gncAddressGetEmail (addr));
/* Setup Ship-to Address */
gtk_entry_set_text (GTK_ENTRY (cw->shipname_entry), gncAddressGetName (shipaddr));
gtk_entry_set_text (GTK_ENTRY (cw->shipaddr1_entry), gncAddressGetAddr1 (shipaddr));
gtk_entry_set_text (GTK_ENTRY (cw->shipaddr2_entry), gncAddressGetAddr2 (shipaddr));
gtk_entry_set_text (GTK_ENTRY (cw->shipaddr3_entry), gncAddressGetAddr3 (shipaddr));
gtk_entry_set_text (GTK_ENTRY (cw->shipaddr4_entry), gncAddressGetAddr4 (shipaddr));
gtk_entry_set_text (GTK_ENTRY (cw->shipphone_entry), gncAddressGetPhone (shipaddr));
gtk_entry_set_text (GTK_ENTRY (cw->shipfax_entry), gncAddressGetFax (shipaddr));
gtk_entry_set_text (GTK_ENTRY (cw->shipemail_entry), gncAddressGetEmail (shipaddr));
/* Set toggle buttons */
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (cw->active_check),
gncCustomerGetActive (cust));
string = gncCustomerGetNotes (cust);
text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW(cw->notes_text));
gtk_text_buffer_set_text (text_buffer, string, -1);
cw->component_id =
gnc_register_gui_component (DIALOG_EDIT_CUSTOMER_CM_CLASS,
gnc_customer_window_refresh_handler,
gnc_customer_window_close_handler,
cw);
cw->terms = gncCustomerGetTerms (cust);
}
else
{
cust = gncCustomerCreate (bookp);
cw->customer_guid = *gncCustomerGetGUID (cust);
cw->dialog_type = NEW_CUSTOMER;
cw->component_id =
gnc_register_gui_component (DIALOG_NEW_CUSTOMER_CM_CLASS,
gnc_customer_window_refresh_handler,
gnc_customer_window_close_handler,
cw);
/* XXX: get the global-default terms */
cw->terms = NULL;
}
/* I know that cust exists here -- either passed in or just created */
cw->taxincluded = gncCustomerGetTaxIncluded (cust);
gnc_taxincluded_combo (GTK_COMBO_BOX(cw->taxincluded_menu), cw->taxincluded);
gnc_billterms_combo (GTK_COMBO_BOX(cw->terms_menu), bookp, TRUE, cw->terms);
cw->taxtable = gncCustomerGetTaxTable (cust);
gnc_taxtables_combo (GTK_COMBO_BOX(cw->taxtable_menu), bookp, TRUE, cw->taxtable);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (cw->taxtable_check),
gncCustomerGetTaxTableOverride (cust));
gnc_customer_taxtable_check_cb (GTK_TOGGLE_BUTTON (cw->taxtable_check), cw);
/* Set up the addr line quickfill */
cw->addr2_quickfill = gnc_get_shared_address_addr2_quickfill(cw->book, ADDR_QUICKFILL);
cw->addr3_quickfill = gnc_get_shared_address_addr3_quickfill(cw->book, ADDR_QUICKFILL);
cw->addr4_quickfill = gnc_get_shared_address_addr4_quickfill(cw->book, ADDR_QUICKFILL);
/* Set the Discount, and Credit amounts */
gnc_amount_edit_set_amount (GNC_AMOUNT_EDIT (cw->discount_amount),
gncCustomerGetDiscount (cust));
gnc_amount_edit_set_amount (GNC_AMOUNT_EDIT (cw->credit_amount),
gncCustomerGetCredit (cust));
gnc_gui_component_watch_entity_type (cw->component_id,
GNC_CUSTOMER_MODULE_NAME,
QOF_EVENT_MODIFY | QOF_EVENT_DESTROY);
gtk_widget_show_all (cw->dialog);
g_object_unref(G_OBJECT(builder));
return cw;
}
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 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 gboolean
gnc_payment_window_check_payment (PaymentWindow *pw)
{
const char *conflict_msg = NULL;
Account *post, *acc;
gnc_numeric amount_deb, amount_cred;
gboolean enable_xfer_acct = TRUE;
GtkTreeSelection *selection;
if (!pw)
return FALSE;
/* Verify the "post" account */
if (!pw->post_acct)
{
conflict_msg = _("You must enter a valid account name for posting.");
goto update_cleanup;
}
/* Verify the user has selected an owner */
gnc_owner_get_owner (pw->owner_choice, &(pw->owner));
if (!gncOwnerIsValid(&pw->owner))
{
conflict_msg = _("You must select a company for payment processing.");
goto update_cleanup;
}
/* Test the total amount */
amount_deb = gnc_amount_edit_get_amount (GNC_AMOUNT_EDIT (pw->amount_debit_edit));
amount_cred = gnc_amount_edit_get_amount (GNC_AMOUNT_EDIT (pw->amount_credit_edit));
pw->amount_tot = gnc_numeric_sub (amount_cred, amount_deb,
gnc_commodity_get_fraction (xaccAccountGetCommodity (pw->post_acct)),
GNC_HOW_RND_ROUND_HALF_UP);
if (gnc_numeric_check (pw->amount_tot) || gnc_numeric_zero_p (pw->amount_tot))
{
enable_xfer_acct = FALSE;
}
else
{
/* Verify the user has selected a transfer account */
pw->xfer_acct = gnc_tree_view_account_get_selected_account (GNC_TREE_VIEW_ACCOUNT(pw->acct_tree));
if (!pw->xfer_acct)
{
conflict_msg = _("You must select a transfer account from the account tree.");
}
}
update_cleanup:
gtk_widget_set_sensitive (pw->acct_tree, enable_xfer_acct);
/* Check if there are issues preventing a successful payment */
gtk_widget_set_tooltip_text (pw->payment_warning, conflict_msg);
if (conflict_msg)
{
gtk_widget_show (pw->payment_warning);
gtk_widget_set_sensitive (pw->ok_button, FALSE);
return FALSE;
}
else
{
gtk_widget_hide (pw->payment_warning);
gtk_widget_set_sensitive (pw->ok_button, TRUE);
}
return TRUE;
}
void
gnc_ui_fincalc_dialog_create(GtkWindow *parent)
{
FinCalcDialog *fcd;
GtkWidget *button;
GtkWidget *combo;
GtkWidget *edit;
GtkWidget *hbox;
GtkBuilder *builder;
if (gnc_forall_gui_components (DIALOG_FINCALC_CM_CLASS,
show_handler, NULL))
return;
fcd = g_new0(FinCalcDialog, 1);
builder = gtk_builder_new();
gnc_builder_add_from_file (builder, "dialog-fincalc.glade", "liststore1");
gnc_builder_add_from_file (builder, "dialog-fincalc.glade", "liststore2");
gnc_builder_add_from_file (builder, "dialog-fincalc.glade", "financial_calculator_dialog");
fcd->dialog = GTK_WIDGET(gtk_builder_get_object (builder, "financial_calculator_dialog"));
// Set the style context for this dialog so it can be easily manipulated with css
gnc_widget_set_style_context (GTK_WIDGET(fcd->dialog), "GncFinCalcDialog");
/* parent */
if (parent != NULL)
gtk_window_set_transient_for (GTK_WINDOW(fcd->dialog), GTK_WINDOW(parent));
gnc_register_gui_component (DIALOG_FINCALC_CM_CLASS,
NULL, close_handler, fcd);
g_signal_connect (G_OBJECT (fcd->dialog), "destroy",
G_CALLBACK (fincalc_dialog_destroy), fcd);
hbox = GTK_WIDGET(gtk_builder_get_object (builder, "payment_periods_hbox"));
edit = gnc_amount_edit_new();
fincalc_init_gae (GNC_AMOUNT_EDIT (edit), 0, 0, 1);
fcd->amounts[PAYMENT_PERIODS] = edit;
gtk_box_pack_end(GTK_BOX(hbox), edit, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT(edit), "changed",
G_CALLBACK (fincalc_update_calc_button_cb), fcd);
button = GTK_WIDGET(gtk_builder_get_object (builder, "payment_periods_clear_button"));
g_object_set_data(G_OBJECT(button), "edit", edit);
hbox = GTK_WIDGET(gtk_builder_get_object (builder, "interest_rate_hbox"));
edit = gnc_amount_edit_new();
fincalc_init_gae (GNC_AMOUNT_EDIT (edit), 2, 5, 100000);
fcd->amounts[INTEREST_RATE] = edit;
gtk_box_pack_end(GTK_BOX(hbox), edit, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT(edit), "changed",
G_CALLBACK (fincalc_update_calc_button_cb), fcd);
button = GTK_WIDGET(gtk_builder_get_object (builder, "interest_rate_clear_button"));
g_object_set_data(G_OBJECT(button), "edit", edit);
hbox = GTK_WIDGET(gtk_builder_get_object (builder, "present_value_hbox"));
edit = gnc_amount_edit_new();
fincalc_init_commodity_gae (GNC_AMOUNT_EDIT (edit));
fcd->amounts[PRESENT_VALUE] = edit;
gtk_box_pack_end(GTK_BOX(hbox), edit, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT(edit), "changed",
G_CALLBACK (fincalc_update_calc_button_cb), fcd);
button = GTK_WIDGET(gtk_builder_get_object (builder, "present_value_clear_button"));
g_object_set_data(G_OBJECT(button), "edit", edit);
hbox = GTK_WIDGET(gtk_builder_get_object (builder, "periodic_payment_hbox"));
edit = gnc_amount_edit_new();
fincalc_init_commodity_gae (GNC_AMOUNT_EDIT (edit));
fcd->amounts[PERIODIC_PAYMENT] = edit;
gtk_box_pack_end(GTK_BOX(hbox), edit, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT(edit), "changed",
G_CALLBACK (fincalc_update_calc_button_cb), fcd);
button = GTK_WIDGET(gtk_builder_get_object (builder, "periodic_payment_clear_button"));
g_object_set_data(G_OBJECT(button), "edit", edit);
hbox = GTK_WIDGET(gtk_builder_get_object (builder, "future_value_hbox"));
edit = gnc_amount_edit_new();
fincalc_init_commodity_gae (GNC_AMOUNT_EDIT (edit));
fcd->amounts[FUTURE_VALUE] = edit;
gtk_box_pack_end(GTK_BOX(hbox), edit, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT(edit), "changed",
G_CALLBACK (fincalc_update_calc_button_cb), fcd);
button = GTK_WIDGET(gtk_builder_get_object (builder, "future_value_clear_button"));
g_object_set_data(G_OBJECT(button), "edit", edit);
fcd->calc_button = GTK_WIDGET(gtk_builder_get_object (builder, "calc_button"));
combo = GTK_WIDGET(gtk_builder_get_object (builder, "compounding_combo"));
fcd->compounding_combo = combo;
g_signal_connect(fcd->compounding_combo, "changed",
G_CALLBACK (fincalc_update_calc_button_cb), fcd);
combo = GTK_WIDGET(gtk_builder_get_object (builder, "payment_combo"));
fcd->payment_combo = combo;
g_signal_connect(fcd->compounding_combo, "changed",
G_CALLBACK (fincalc_update_calc_button_cb), fcd);
button = GTK_WIDGET(gtk_builder_get_object (builder, "period_payment_radio"));
fcd->end_of_period_radio = button;
button = GTK_WIDGET(gtk_builder_get_object (builder, "discrete_compounding_radio"));
fcd->discrete_compounding_radio = button;
fcd->payment_total_label = GTK_WIDGET(gtk_builder_get_object (builder, "payment_total_label"));
button = GTK_WIDGET(gtk_builder_get_object (builder, "schedule_button"));
gtk_widget_hide (button);
init_fi(fcd);
fi_to_gui(fcd);
gtk_widget_grab_focus(fcd->amounts[PAYMENT_PERIODS]);
/* Connect all signals specified in glade. */
gtk_builder_connect_signals(builder, fcd);
g_object_unref(G_OBJECT(builder));
gnc_restore_window_size(GNC_PREFS_GROUP, GTK_WINDOW(fcd->dialog));
gtk_widget_show(fcd->dialog);
}
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);
}
GncABTransDialog *
gnc_ab_trans_dialog_new(GtkWidget *parent, AB_ACCOUNT *ab_acc,
gint commodity_scu, GncABTransType trans_type,
GList *templates)
{
GncABTransDialog *td;
GtkBuilder *builder;
const gchar *ab_ownername;
const gchar *ab_accountnumber;
const gchar *ab_bankname;
const gchar *ab_bankcode;
GtkWidget *heading_label;
GtkWidget *recp_name_heading;
GtkWidget *recp_account_heading;
GtkWidget *recp_bankcode_heading;
GtkWidget *amount_hbox;
GtkWidget *orig_name_heading;
GtkWidget *orig_name_label;
GtkWidget *orig_account_heading;
GtkWidget *orig_account_label;
GtkWidget *orig_bankname_heading;
GtkWidget *orig_bankname_label;
GtkWidget *orig_bankcode_heading;
GtkWidget *orig_bankcode_label;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
g_return_val_if_fail(ab_acc, NULL);
ab_ownername = AB_Account_GetOwnerName(ab_acc);
if (!ab_ownername)
ab_ownername = "";
ab_accountnumber = AB_Account_GetAccountNumber(ab_acc);
ab_bankcode = AB_Account_GetBankCode(ab_acc);
ab_bankname = AB_Account_GetBankName(ab_acc);
if (!ab_bankname || !*ab_bankname)
ab_bankname = _("(unknown)");
td = g_new0(GncABTransDialog, 1);
td->parent = parent;
td->ab_acc = ab_acc;
td->trans_type = trans_type;
#if HAVE_KTOBLZCHECK_H
td->blzcheck = AccountNumberCheck_new();
#endif
builder = gtk_builder_new();
gnc_builder_add_from_file (builder, "dialog-ab.glade", "Transaction Dialog");
td->dialog = GTK_WIDGET(gtk_builder_get_object (builder, "Transaction Dialog"));
if (parent)
gtk_window_set_transient_for(GTK_WINDOW(td->dialog), GTK_WINDOW(parent));
/* Extract widgets */
heading_label = GTK_WIDGET(gtk_builder_get_object (builder, "heading_label"));
recp_name_heading = GTK_WIDGET(gtk_builder_get_object (builder, "recp_name_heading"));
td->recp_name_entry = GTK_WIDGET(gtk_builder_get_object (builder, "recp_name_entry"));
recp_account_heading = GTK_WIDGET(gtk_builder_get_object (builder, "recp_account_heading"));
td->recp_account_entry = GTK_WIDGET(gtk_builder_get_object (builder, "recp_account_entry"));
recp_bankcode_heading = GTK_WIDGET(gtk_builder_get_object (builder, "recp_bankcode_heading"));
td->recp_bankcode_entry = GTK_WIDGET(gtk_builder_get_object (builder, "recp_bankcode_entry"));
td->recp_bankname_label = GTK_WIDGET(gtk_builder_get_object (builder, "recp_bankname_label"));
amount_hbox = GTK_WIDGET(gtk_builder_get_object (builder, "amount_hbox"));
td->purpose_entry = GTK_WIDGET(gtk_builder_get_object (builder, "purpose_entry"));
td->purpose_cont_entry = GTK_WIDGET(gtk_builder_get_object (builder, "purpose_cont_entry"));
td->purpose_cont2_entry = GTK_WIDGET(gtk_builder_get_object (builder, "purpose_cont2_entry"));
td->purpose_cont3_entry = GTK_WIDGET(gtk_builder_get_object (builder, "purpose_cont3_entry"));
orig_name_heading = GTK_WIDGET(gtk_builder_get_object (builder, "orig_name_heading"));
orig_name_label = GTK_WIDGET(gtk_builder_get_object (builder, "orig_name_label"));
orig_account_heading = GTK_WIDGET(gtk_builder_get_object (builder, "orig_account_heading"));
orig_account_label = GTK_WIDGET(gtk_builder_get_object (builder, "orig_account_label"));
orig_bankname_heading = GTK_WIDGET(gtk_builder_get_object (builder, "orig_bankname_heading"));
orig_bankname_label = GTK_WIDGET(gtk_builder_get_object (builder, "orig_bankname_label"));
orig_bankcode_heading = GTK_WIDGET(gtk_builder_get_object (builder, "orig_bankcode_heading"));
orig_bankcode_label = GTK_WIDGET(gtk_builder_get_object (builder, "orig_bankcode_label"));
td->template_gtktreeview =
GTK_TREE_VIEW(gtk_builder_get_object (builder, "template_list"));
/* Amount edit */
td->amount_edit = gnc_amount_edit_new();
gtk_box_pack_start_defaults(GTK_BOX(amount_hbox), td->amount_edit);
gnc_amount_edit_set_evaluate_on_enter(GNC_AMOUNT_EDIT(td->amount_edit),
TRUE);
gnc_amount_edit_set_fraction(GNC_AMOUNT_EDIT(td->amount_edit),
commodity_scu);
/* Check for what kind of transaction this should be, and change the
* labels accordingly */
switch (trans_type)
{
case SINGLE_TRANSFER:
case SINGLE_INTERNAL_TRANSFER:
/* all labels are already set */
break;
case SINGLE_DEBITNOTE:
gtk_label_set_text(GTK_LABEL (heading_label),
/* Translators: Strings from this file are
* needed only in countries that have one of
* aqbanking's Online Banking techniques
* available. This is 'OFX DirectConnect'
* (U.S. and others), 'HBCI' (in Germany),
* or 'YellowNet' (Switzerland). If none of
* these techniques are available in your
* country, you may safely ignore strings
* from the import-export/hbci
* subdirectory. */
_("Enter an Online Direct Debit Note"));
gtk_label_set_text(GTK_LABEL(recp_name_heading),
_("Debited Account Owner"));
gtk_label_set_text(GTK_LABEL(recp_account_heading),
_("Debited Account Number"));
gtk_label_set_text(GTK_LABEL(recp_bankcode_heading),
_("Debited Account Bank Code"));
gtk_label_set_text(GTK_LABEL(orig_name_heading),
_("Credited Account Owner"));
gtk_label_set_text(GTK_LABEL(orig_account_heading),
_("Credited Account Number"));
gtk_label_set_text(GTK_LABEL(orig_bankcode_heading),
_("Credited Account Bank Code"));
break;
default:
g_critical("gnc_ab_trans_dialog_new: Oops, unknown GncABTransType %d",
trans_type);
break;
}
gtk_label_set_text(GTK_LABEL(orig_name_label), ab_ownername);
gtk_label_set_text(GTK_LABEL(orig_account_label), ab_accountnumber);
gtk_label_set_text(GTK_LABEL(orig_bankname_label), ab_bankname);
gtk_label_set_text (GTK_LABEL (orig_bankcode_label), ab_bankcode);
/* Fill list for choosing a transaction template */
td->template_list_store = gtk_list_store_new(TEMPLATE_NUM_COLUMNS,
G_TYPE_STRING, G_TYPE_POINTER);
g_list_foreach(templates, fill_templ_helper, td->template_list_store);
gtk_tree_view_set_model(td->template_gtktreeview,
GTK_TREE_MODEL(td->template_list_store));
td->templ_changed = FALSE;
/* Keep a reference to the store */
/* Show this list */
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(
"Template Name", renderer, "text", TEMPLATE_NAME, NULL);
gtk_tree_view_append_column(td->template_gtktreeview, column);
/* Connect the Signals */
gtk_builder_connect_signals_full (builder, gnc_builder_connect_full_func, td);
g_object_unref(G_OBJECT(builder));
return td;
}
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 GncTaxTable *
new_tax_table_dialog (TaxTableWindow *ttw, gboolean new_table,
GncTaxTableEntry *entry, const char *name)
{
GncTaxTable *created_table = NULL;
NewTaxTable *ntt;
GtkBuilder *builder;
GtkWidget *box, *widget, *combo;
gboolean done;
gint response, index;
if (!ttw) return NULL;
if (new_table && entry) return NULL;
ntt = g_new0 (NewTaxTable, 1);
ntt->ttw = ttw;
ntt->entry = entry;
ntt->new_table = new_table;
if (entry)
ntt->type = gncTaxTableEntryGetType (entry);
else
ntt->type = GNC_AMT_TYPE_PERCENT;
/* Open and read the Glade File */
builder = gtk_builder_new();
gnc_builder_add_from_file (builder, "dialog-tax-table.glade", "type_liststore");
gnc_builder_add_from_file (builder, "dialog-tax-table.glade", "New Tax Table Dialog");
ntt->dialog = GTK_WIDGET(gtk_builder_get_object (builder, "New Tax Table Dialog"));
ntt->name_entry = GTK_WIDGET(gtk_builder_get_object (builder, "name_entry"));
if (name)
gtk_entry_set_text (GTK_ENTRY (ntt->name_entry), name);
/* Create the menu */
combo = GTK_WIDGET(gtk_builder_get_object (builder, "type_combobox"));
index = ntt->type ? ntt->type : GNC_AMT_TYPE_VALUE;
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), index - 1);
g_signal_connect (combo, "changed", G_CALLBACK (combo_changed), ntt);
/* Attach our own widgets */
box = GTK_WIDGET(gtk_builder_get_object (builder, "amount_box"));
ntt->amount_entry = widget = gnc_amount_edit_new ();
gnc_amount_edit_set_evaluate_on_enter (GNC_AMOUNT_EDIT (widget), TRUE);
gnc_amount_edit_set_fraction (GNC_AMOUNT_EDIT (widget), 100000);
gtk_box_pack_start (GTK_BOX (box), widget, TRUE, TRUE, 0);
box = GTK_WIDGET(gtk_builder_get_object (builder, "acct_window"));
ntt->acct_tree = GTK_WIDGET(gnc_tree_view_account_new (FALSE));
gtk_container_add (GTK_CONTAINER (box), ntt->acct_tree);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(ntt->acct_tree), FALSE);
/* Make 'enter' do the right thing */
gtk_entry_set_activates_default(GTK_ENTRY (gnc_amount_edit_gtk_entry
(GNC_AMOUNT_EDIT (ntt->amount_entry))),
TRUE);
/* Fix mnemonics for generated target widgets */
widget = GTK_WIDGET(gtk_builder_get_object (builder, "value_label"));
gtk_label_set_mnemonic_widget (GTK_LABEL (widget), ntt->amount_entry);
widget = GTK_WIDGET(gtk_builder_get_object (builder, "account_label"));
gtk_label_set_mnemonic_widget (GTK_LABEL (widget), ntt->acct_tree);
/* Fill in the widgets appropriately */
if (entry)
{
gnc_amount_edit_set_amount (GNC_AMOUNT_EDIT (ntt->amount_entry),
gncTaxTableEntryGetAmount (entry));
gnc_tree_view_account_set_selected_account (GNC_TREE_VIEW_ACCOUNT (ntt->acct_tree),
gncTaxTableEntryGetAccount (entry));
}
/* Set our parent */
gtk_window_set_transient_for (GTK_WINDOW(ntt->dialog), GTK_WINDOW(ttw->dialog));
/* Setup signals */
gtk_builder_connect_signals_full (builder, gnc_builder_connect_full_func, ntt);
/* Show what we should */
gtk_widget_show_all (ntt->dialog);
if (new_table == FALSE)
{
gtk_widget_hide (GTK_WIDGET(gtk_builder_get_object (builder, "table_title")));
gtk_widget_hide (GTK_WIDGET(gtk_builder_get_object (builder, "table_name")));
gtk_widget_hide (GTK_WIDGET(gtk_builder_get_object (builder, "spacer")));
gtk_widget_hide (ntt->name_entry);
/* Tables are great for layout, but a pain when you hide widgets */
widget = GTK_WIDGET(gtk_builder_get_object (builder, "ttd_table"));
gtk_table_set_row_spacing (GTK_TABLE(widget), 0, 0);
gtk_table_set_row_spacing (GTK_TABLE(widget), 1, 0);
gtk_table_set_row_spacing (GTK_TABLE(widget), 2, 0);
gtk_widget_grab_focus (gnc_amount_edit_gtk_entry
(GNC_AMOUNT_EDIT (ntt->amount_entry)));
}
else
gtk_widget_grab_focus (ntt->name_entry);
/* Display the dialog now that we're done manipulating it */
gtk_widget_show (ntt->dialog);
done = FALSE;
while (!done)
{
response = gtk_dialog_run (GTK_DIALOG (ntt->dialog));
switch (response)
{
case GTK_RESPONSE_OK:
if (new_tax_table_ok_cb (ntt))
{
created_table = ntt->created_table;
done = TRUE;
}
break;
default:
done = TRUE;
break;
}
}
g_object_unref(G_OBJECT(builder));
gtk_widget_destroy(ntt->dialog);
g_free(ntt);
return created_table;
}
void
templ_list_row_activated_cb(GtkTreeView *view, GtkTreePath *path,
GtkTreeViewColumn *column, gpointer user_data)
{
GncABTransDialog *td = user_data;
GtkTreeModel *model;
GtkTreeIter iter;
GncABTransTempl *templ;
const gchar *old_name, *new_name;
const gchar *old_account, *new_account;
const gchar *old_bankcode, *new_bankcode;
const gchar *old_purpose, *new_purpose;
const gchar *old_purpose_cont, *new_purpose_cont;
GtkWidget *amount_widget;
const gchar *old_amount_text;
gnc_numeric old_amount, new_amount;
g_return_if_fail(td);
ENTER("td=%p", td);
if (!gtk_tree_model_get_iter(GTK_TREE_MODEL(td->template_list_store), &iter,
path))
{
LEAVE("Could not get iter");
return;
}
gtk_tree_model_get(GTK_TREE_MODEL(td->template_list_store), &iter,
TEMPLATE_POINTER, &templ, -1);
/* Get old values */
old_name = gtk_entry_get_text(GTK_ENTRY(td->recp_name_entry));
old_account = gtk_entry_get_text(GTK_ENTRY(td->recp_account_entry));
old_bankcode = gtk_entry_get_text(GTK_ENTRY(td->recp_bankcode_entry));
old_purpose = gtk_entry_get_text(GTK_ENTRY(td->purpose_entry));
old_purpose_cont = gtk_entry_get_text(GTK_ENTRY(td->purpose_cont_entry));
amount_widget = gnc_amount_edit_gtk_entry(GNC_AMOUNT_EDIT(td->amount_edit));
old_amount_text = gtk_entry_get_text(GTK_ENTRY(amount_widget));
old_amount = gnc_amount_edit_get_amount(GNC_AMOUNT_EDIT(td->amount_edit));
/* Get new values */
new_name = gnc_ab_trans_templ_get_recp_name(templ);
new_account = gnc_ab_trans_templ_get_recp_account(templ);
new_bankcode = gnc_ab_trans_templ_get_recp_bankcode(templ);
new_purpose = gnc_ab_trans_templ_get_purpose(templ);
new_purpose_cont = gnc_ab_trans_templ_get_purpose_cont(templ);
new_amount = gnc_ab_trans_templ_get_amount(templ);
if (!new_name) new_name = "";
if (!new_account) new_account = "";
if (!new_bankcode) new_bankcode = "";
if (!new_purpose) new_purpose = "";
if (!new_purpose_cont) new_purpose_cont = "";
/* Check for differences to avoid overwriting entered text */
if ((*old_name && strcmp(old_name, new_name))
|| (*old_account && strcmp(old_account, new_account))
|| (*old_bankcode && strcmp(old_bankcode, new_bankcode))
|| (*old_purpose && strcmp(old_purpose, new_purpose))
|| (*old_purpose_cont && strcmp(old_purpose_cont, new_purpose_cont))
|| (*old_amount_text && !gnc_numeric_equal(old_amount, new_amount)))
{
if (!gnc_verify_dialog(
td->parent, FALSE,
_("Do you really want to overwrite your changes with the "
"contents of the template \"%s\"?"),
gnc_ab_trans_templ_get_name(templ)))
{
LEAVE("aborted");
return;
}
}
/* Fill in */
gtk_entry_set_text(GTK_ENTRY(td->recp_name_entry), new_name);
gtk_entry_set_text(GTK_ENTRY(td->recp_account_entry), new_account);
gtk_entry_set_text(GTK_ENTRY(td->recp_bankcode_entry), new_bankcode);
gtk_entry_set_text(GTK_ENTRY(td->purpose_entry), new_purpose);
gtk_entry_set_text(GTK_ENTRY(td->purpose_cont_entry), new_purpose_cont);
gnc_amount_edit_set_amount(GNC_AMOUNT_EDIT(td->amount_edit), new_amount);
LEAVE(" ");
}
/* Determine whether the value can be calculated. If it can, return
* NULL. Otherwise, return a string describing the reason and the offending
* entry in error_item. */
static const char *
can_calc_value(FinCalcDialog *fcd, FinCalcValue value, int *error_item)
{
const char *missing = _("This program can only calculate one value at a time. "
"You must enter values for all but one quantity.");
const char *bad_exp = _("GnuCash cannot determine the value in one of the fields. "
"You must enter a valid expression.");
const char *string;
gnc_numeric nvalue;
unsigned int i;
if (fcd == NULL)
return NULL;
/* Check for missing values */
for (i = 0; i < NUM_FIN_CALC_VALUES; i++)
if (i != value)
{
string = gtk_entry_get_text(GTK_ENTRY(fcd->amounts[i]));
if ((string == NULL) || (*string == '\0'))
{
*error_item = i;
return missing;
}
if (!gnc_amount_edit_evaluate (GNC_AMOUNT_EDIT (fcd->amounts[i])))
{
*error_item = i;
return bad_exp;
}
}
/* Check for zero interest */
switch (value)
{
case PAYMENT_PERIODS:
case PRESENT_VALUE:
case PERIODIC_PAYMENT:
case FUTURE_VALUE:
nvalue = gnc_amount_edit_get_amount
(GNC_AMOUNT_EDIT (fcd->amounts[INTEREST_RATE]));
if (gnc_numeric_zero_p (nvalue))
{
*error_item = INTEREST_RATE;
return _("The interest rate cannot be zero.");
}
break;
default:
break;
}
/* Check for zero payment periods */
switch (value)
{
case INTEREST_RATE:
case PRESENT_VALUE:
case PERIODIC_PAYMENT:
case FUTURE_VALUE:
nvalue = gnc_amount_edit_get_amount
(GNC_AMOUNT_EDIT(fcd->amounts[PAYMENT_PERIODS]));
if (gnc_numeric_zero_p (nvalue))
{
*error_item = PAYMENT_PERIODS;
return _("The number of payments cannot be zero.");
}
if (gnc_numeric_negative_p (nvalue))
{
*error_item = PAYMENT_PERIODS;
return _("The number of payments cannot be negative.");
}
break;
default:
break;
}
return NULL;
}
static GtkWidget *
gnc_stock_split_assistant_create (StockSplitInfo *info)
{
GtkBuilder *builder;
GtkWidget *window;
builder = gtk_builder_new();
gnc_builder_add_from_file (builder , "assistant-stock-split.glade", "stock_split_assistant");
window = GTK_WIDGET(gtk_builder_get_object (builder, "stock_split_assistant"));
info->window = window;
// Set the style context for this assistant so it can be easily manipulated with css
gnc_widget_set_style_context (GTK_WIDGET(window), "GncAssistStockSplit");
/* Enable buttons on first, second, fourth and last page. */
gtk_assistant_set_page_complete (GTK_ASSISTANT (window),
GTK_WIDGET(gtk_builder_get_object(builder, "intro_page_label")),
TRUE);
gtk_assistant_set_page_complete (GTK_ASSISTANT (window),
GTK_WIDGET(gtk_builder_get_object(builder, "stock_account_page")),
TRUE);
gtk_assistant_set_page_complete (GTK_ASSISTANT (window),
GTK_WIDGET(gtk_builder_get_object(builder, "stock_cash_page")),
TRUE);
gtk_assistant_set_page_complete (GTK_ASSISTANT (window),
GTK_WIDGET(gtk_builder_get_object(builder, "finish_page_label")),
TRUE);
/* Account page Widgets */
{
GtkTreeView *view;
GtkListStore *store;
GtkTreeSelection *selection;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
info->account_view = GTK_WIDGET(gtk_builder_get_object(builder, "account_view"));
view = GTK_TREE_VIEW(info->account_view);
// Set grid lines option to preference
gtk_tree_view_set_grid_lines (GTK_TREE_VIEW(view), gnc_tree_view_get_grid_lines_pref ());
store = gtk_list_store_new(NUM_SPLIT_COLS, G_TYPE_POINTER, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING);
gtk_tree_view_set_model(view, GTK_TREE_MODEL(store));
g_object_unref(store);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Account"), renderer,
"text", SPLIT_COL_FULLNAME,
NULL);
gtk_tree_view_append_column(view, column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Symbol"), renderer,
"text", SPLIT_COL_MNEMONIC,
NULL);
gtk_tree_view_append_column(view, column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Shares"), renderer,
"text", SPLIT_COL_SHARES,
NULL);
gtk_tree_view_append_column(view, column);
selection = gtk_tree_view_get_selection(view);
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
g_signal_connect (selection, "changed",
G_CALLBACK (selection_changed_cb), info);
}
/* Details Page Widgets */
{
GtkWidget *table;
GtkWidget *amount;
GtkWidget *date;
GtkWidget *label;
table = GTK_WIDGET(gtk_builder_get_object(builder, "stock_details_table"));
info->description_entry = GTK_WIDGET(gtk_builder_get_object(builder, "description_entry"));
date = gnc_date_edit_new (gnc_time (NULL), FALSE, FALSE);
gtk_grid_attach (GTK_GRID(table), date, 1, 0, 1, 1);
gtk_widget_show (date);
info->date_edit = date;
label = GTK_WIDGET(gtk_builder_get_object(builder, "date_label"));
gnc_date_make_mnemonic_target (GNC_DATE_EDIT(date), label);
amount = gnc_amount_edit_new ();
g_signal_connect (amount, "changed",
G_CALLBACK (gnc_stock_split_details_valid_cb), info);
gnc_amount_edit_set_evaluate_on_enter (GNC_AMOUNT_EDIT (amount), TRUE);
gtk_grid_attach (GTK_GRID(table), amount, 1, 1, 1, 1);
gtk_widget_show (amount);
info->distribution_edit = amount;
label = GTK_WIDGET(gtk_builder_get_object(builder, "distribution_label"));
gtk_label_set_mnemonic_widget(GTK_LABEL(label), amount);
amount = gnc_amount_edit_new ();
gnc_amount_edit_set_print_info (GNC_AMOUNT_EDIT (amount),
gnc_default_price_print_info ());
g_signal_connect (amount, "changed",
G_CALLBACK (gnc_stock_split_details_valid_cb), info);
gnc_amount_edit_set_evaluate_on_enter (GNC_AMOUNT_EDIT (amount), TRUE);
gtk_grid_attach (GTK_GRID(table), amount, 1, 5, 1, 1);
gtk_widget_show (amount);
info->price_edit = amount;
label = GTK_WIDGET(gtk_builder_get_object(builder, "price_label"));
gtk_label_set_mnemonic_widget(GTK_LABEL(label), amount);
info->price_currency_edit = gnc_currency_edit_new();
gnc_currency_edit_set_currency (GNC_CURRENCY_EDIT(info->price_currency_edit), gnc_default_currency());
gtk_widget_show (info->price_currency_edit);
gtk_grid_attach (GTK_GRID(table), info->price_currency_edit, 1, 6, 1, 1);
}
/* Cash page Widgets */
{
GtkWidget *box;
GtkWidget *tree;
GtkWidget *amount;
GtkWidget *label;
GtkWidget *scroll;
GtkTreeSelection *selection;
box = GTK_WIDGET(gtk_builder_get_object(builder, "cash_box"));
amount = gnc_amount_edit_new ();
g_signal_connect (amount, "changed",
G_CALLBACK (gnc_stock_split_cash_valid_cb), info);
gnc_amount_edit_set_evaluate_on_enter (GNC_AMOUNT_EDIT (amount), TRUE);
gtk_box_pack_start (GTK_BOX (box), amount, TRUE, TRUE, 0);
info->cash_edit = amount;
label = GTK_WIDGET(gtk_builder_get_object(builder, "cash_label"));
gtk_label_set_mnemonic_widget(GTK_LABEL(label), amount);
info->memo_entry = GTK_WIDGET(gtk_builder_get_object(builder, "memo_entry"));
/* income tree */
tree = GTK_WIDGET(gnc_tree_view_account_new (FALSE));
info->income_tree = tree;
gnc_tree_view_account_set_filter (GNC_TREE_VIEW_ACCOUNT (tree),
gnc_stock_split_assistant_view_filter_income,
NULL, /* user data */
NULL /* destroy callback */);
gtk_widget_show (tree);
gtk_tree_view_expand_all (GTK_TREE_VIEW(tree));
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(tree));
gtk_tree_selection_unselect_all (selection);
g_signal_connect (selection, "changed",
G_CALLBACK (gnc_stock_split_cash_valid_cb), info);
label = GTK_WIDGET(gtk_builder_get_object(builder, "income_label"));
gtk_label_set_mnemonic_widget (GTK_LABEL(label), tree);
scroll = GTK_WIDGET(gtk_builder_get_object(builder, "income_scroll"));
gtk_container_add (GTK_CONTAINER (scroll), tree);
/* asset tree */
tree = GTK_WIDGET(gnc_tree_view_account_new (FALSE));
info->asset_tree = tree;
gnc_tree_view_account_set_filter (GNC_TREE_VIEW_ACCOUNT (tree),
gnc_stock_split_assistant_view_filter_asset,
NULL /* user data */,
NULL /* destroy callback */);
gtk_widget_show (tree);
label = GTK_WIDGET(gtk_builder_get_object(builder, "asset_label"));
gtk_label_set_mnemonic_widget (GTK_LABEL(label), tree);
scroll = GTK_WIDGET(gtk_builder_get_object(builder, "asset_scroll"));
gtk_container_add (GTK_CONTAINER (scroll), tree);
gtk_tree_view_expand_all (GTK_TREE_VIEW(tree));
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(tree));
gtk_tree_selection_unselect_all (selection);
g_signal_connect (selection, "changed",
G_CALLBACK (gnc_stock_split_cash_valid_cb), info);
}
g_signal_connect (G_OBJECT(window), "destroy",
G_CALLBACK (gnc_stock_split_assistant_window_destroy_cb), info);
gtk_builder_connect_signals(builder, info);
g_object_unref(G_OBJECT(builder));
return window;
}
void
dat_add_templ_cb(GtkButton *button, gpointer user_data)
{
GncABTransDialog *td = user_data;
GtkBuilder *builder;
GtkWidget *dialog;
GtkWidget *entry;
gint retval;
const gchar *name;
GncABTransTempl *templ;
struct _FindTemplData data;
GtkTreeSelection *selection;
GtkTreeIter cur_iter;
GtkTreeIter new_iter;
g_return_if_fail(td);
ENTER("td=%p", td);
builder = gtk_builder_new();
gnc_builder_add_from_file (builder, "dialog-ab.glade", "Template Name Dialog");
dialog = GTK_WIDGET(gtk_builder_get_object (builder, "Template Name Dialog"));
entry = GTK_WIDGET(gtk_builder_get_object (builder, "template_name"));
/* Suggest recipient name as name of the template */
gtk_entry_set_text(GTK_ENTRY(entry),
gtk_entry_get_text(GTK_ENTRY(td->recp_name_entry)));
do
{
retval = gtk_dialog_run(GTK_DIALOG(dialog));
if (retval != GTK_RESPONSE_OK)
break;
name = gtk_entry_get_text(GTK_ENTRY(entry));
if (!*name)
break;
data.name = name;
data.pointer = NULL;
gtk_tree_model_foreach(GTK_TREE_MODEL(td->template_list_store),
find_templ_helper, &data);
if (data.pointer)
{
gnc_error_dialog(dialog, "%s",
_("A template with the given name already exists. "
"Please enter another name."));
continue;
}
/* Create a new template */
templ = gnc_ab_trans_templ_new_full(
name,
gtk_entry_get_text(GTK_ENTRY(td->recp_name_entry)),
gtk_entry_get_text(GTK_ENTRY(td->recp_account_entry)),
gtk_entry_get_text(GTK_ENTRY(td->recp_bankcode_entry)),
gnc_amount_edit_get_amount(GNC_AMOUNT_EDIT(td->amount_edit)),
gtk_entry_get_text(GTK_ENTRY(td->purpose_entry)),
gtk_entry_get_text (GTK_ENTRY(td->purpose_cont_entry)));
/* Insert it, either after the selected one or at the end */
selection = gtk_tree_view_get_selection(td->template_gtktreeview);
if (gtk_tree_selection_get_selected(selection, NULL, &cur_iter))
{
gtk_list_store_insert_after(td->template_list_store,
&new_iter, &cur_iter);
}
else
{
gtk_list_store_append(td->template_list_store, &new_iter);
}
gtk_list_store_set(td->template_list_store, &new_iter,
TEMPLATE_NAME, name,
TEMPLATE_POINTER, templ,
-1);
td->templ_changed = TRUE;
DEBUG("Added template with name %s", name);
break;
}
while (TRUE);
g_object_unref(G_OBJECT(builder));
gtk_widget_destroy(dialog);
LEAVE(" ");
}
