DialogQueryList *
gnc_dialog_query_list_new (GList *param_list, Query *q)
{
GladeXML *xml;
DialogQueryList *dql;
GtkWidget *scroller, *close;
GList *node;
dql = g_new0 (DialogQueryList, 1);
xml = gnc_glade_xml_new ("dialog-query-list.glade", "Query List Dialog");
/* Grab the dialog, save the dialog info */
dql->dialog = glade_xml_get_widget (xml, "Query List Dialog");
g_object_set_data (G_OBJECT (dql->dialog), "dialog-info", dql);
/* grab the widgets */
dql->label = glade_xml_get_widget (xml, "dialog_label");
dql->button_box = glade_xml_get_widget (xml, "button_vbox");
scroller = glade_xml_get_widget (xml, "result_scroller");
close = glade_xml_get_widget (xml, "close_button");
/* build the query list */
dql->qlist = gnc_query_list_new (param_list, q);
gtk_container_add (GTK_CONTAINER (scroller), dql->qlist);
/* connect the double-click signal of the qlist */
g_signal_connect (G_OBJECT (dql->qlist), "double_click_entry",
G_CALLBACK(gnc_dialog_query_list_double_click_entry), dql);
/* connect to the close button */
g_signal_connect (G_OBJECT (close), "clicked",
G_CALLBACK (gnc_dialog_query_list_close), dql);
/* connect to the cleanup */
g_signal_connect (G_OBJECT (dql->dialog), "delete_event",
G_CALLBACK (gnc_dialog_query_list_delete_cb), dql);
/* register ourselves */
dql->component_id =
gnc_register_gui_component ("GNC Dialog Query List",
gnc_dialog_query_list_refresh_handler,
close_handler, dql);
/* Build the book list */
dql_build_booklist (dql, q);
/* and register the books */
for (node = dql->books; node; node = node->next)
gnc_gui_component_watch_entity (dql->component_id, (GncGUID*)node->data,
QOF_EVENT_DESTROY);
return dql;
}
gboolean
gnc_hbci_get_password (GtkWidget *parent,
const char *windowtitle,
const char *heading,
const char *initial_password,
char **password,
gboolean hide_input)
{
GtkWidget *dialog;
GtkWidget *heading_label;
GtkWidget *password_entry;
GladeXML *xml;
gint result;
g_return_val_if_fail (password != NULL, FALSE);
xml = gnc_glade_xml_new ("hbcipass.glade", "Password Dialog");
dialog = glade_xml_get_widget (xml, "Password Dialog");
if (parent)
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (parent));
heading_label = glade_xml_get_widget (xml, "heading_label");
password_entry = glade_xml_get_widget (xml, "password_entry");
g_assert(heading_label && password_entry);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), 1);
gtk_entry_set_activates_default (GTK_ENTRY (password_entry), TRUE);
if (windowtitle)
gtk_window_set_title (GTK_WINDOW (dialog), windowtitle);
if (heading)
gtk_label_set_text (GTK_LABEL (heading_label), heading);
if (initial_password)
gtk_entry_set_text (GTK_ENTRY (password_entry), initial_password);
gtk_entry_set_visibility (GTK_ENTRY (password_entry), !hide_input);
result = gtk_dialog_run (GTK_DIALOG (dialog));
if (result == 1) /* the hand-assigned response value */
{
*password = g_strdup (gtk_entry_get_text (GTK_ENTRY (password_entry)) );
gtk_widget_destroy(dialog);
return TRUE;
}
gtk_widget_destroy(dialog);
*password = NULL;
return FALSE;
}
static void
gnc_column_view_edit_size_cb(GtkButton * button, gpointer user_data)
{
gnc_column_view_edit * r = user_data;
GtkWidget * rowspin;
GtkWidget * colspin;
GtkWidget * dlg;
GladeXML *xml;
SCM current;
int length;
int dlg_ret;
xml = gnc_glade_xml_new ("report.glade", "Edit Report Size");
dlg = glade_xml_get_widget (xml, "Edit Report Size");
/* get the spinner widgets */
rowspin = glade_xml_get_widget (xml, "row_spin");
colspin = glade_xml_get_widget (xml, "col_spin");
length = scm_ilength(r->contents_list);
if (length > r->contents_selected)
{
current = scm_list_ref(r->contents_list,
scm_int2num(r->contents_selected));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(colspin),
(float)scm_num2int(SCM_CADR(current),
SCM_ARG1, G_STRFUNC));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(rowspin),
(float)scm_num2int(SCM_CADDR(current),
SCM_ARG1, G_STRFUNC));
dlg_ret = gtk_dialog_run(GTK_DIALOG(dlg));
gtk_widget_hide(dlg);
if (dlg_ret == GTK_RESPONSE_OK)
{
current = SCM_LIST4(SCM_CAR(current),
scm_int2num(gtk_spin_button_get_value_as_int
(GTK_SPIN_BUTTON(colspin))),
scm_int2num(gtk_spin_button_get_value_as_int
(GTK_SPIN_BUTTON(rowspin))),
SCM_BOOL_F);
scm_gc_unprotect_object(r->contents_list);
r->contents_list = scm_list_set_x(r->contents_list,
scm_int2num(r->contents_selected),
current);
scm_gc_protect_object(r->contents_list);
gnc_options_dialog_changed (r->optwin);
update_display_lists(r);
}
gtk_widget_destroy(dlg);
}
}
/********************************************************************\
* 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 void
setup_dialog(GncGWENGui *gui)
{
GladeXML *xml;
gint component_id;
g_return_if_fail(gui);
ENTER("gui=%p", gui);
xml = gnc_glade_xml_new("aqbanking.glade", "Connection Dialog");
gui->dialog = glade_xml_get_widget(xml, "Connection Dialog");
g_object_set_data_full(G_OBJECT(gui->dialog), "xml", xml, g_object_unref);
glade_xml_signal_autoconnect_full(xml, gnc_glade_autoconnect_full_func, gui);
gui->entries_table = glade_xml_get_widget(xml, "entries_table");
gui->top_entry = glade_xml_get_widget(xml, "top_entry");
gui->top_progress = glade_xml_get_widget(xml, "top_progress");
gui->second_entry = glade_xml_get_widget(xml, "second_entry");
gui->other_entries_box = NULL;
gui->progresses = NULL;
gui->log_text = glade_xml_get_widget(xml, "log_text");
gui->abort_button = glade_xml_get_widget(xml, "abort_button");
gui->close_button = glade_xml_get_widget(xml, "close_button");
gui->close_checkbutton = glade_xml_get_widget(xml, "close_checkbutton");
gui->accepted_certs = NULL;
gui->permanently_accepted_certs = NULL;
gui->showbox_hash = NULL;
gui->showbox_id = 1;
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(gui->close_checkbutton),
gnc_gconf_get_bool(GCONF_SECTION_AQBANKING, KEY_CLOSE_ON_FINISH, NULL));
component_id = gnc_register_gui_component(GWEN_GUI_CM_CLASS, NULL,
cm_close_handler, gui);
gnc_gui_component_set_session(component_id, gnc_get_current_session());
reset_dialog(gui);
LEAVE(" ");
}
void
gnc_prices_dialog_remove_old_clicked (GtkWidget *widget, gpointer data)
{
PricesDialog *pdb_dialog = data;
GladeXML *xml;
GtkWidget *dialog, *button, *date, *label;
gint result;
gboolean delete_user, delete_last;
ENTER(" ");
xml = gnc_glade_xml_new ("price.glade", "Deletion Date");
dialog = glade_xml_get_widget (xml, "Deletion Date");
date = glade_xml_get_widget (xml, "date");
label = glade_xml_get_widget (xml, "date_label");
gnc_date_make_mnemonic_target (GNC_DATE_EDIT(date), label);
glade_xml_signal_autoconnect_full(xml, gnc_glade_autoconnect_full_func, pdb_dialog);
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (pdb_dialog->dialog));
result = gtk_dialog_run (GTK_DIALOG (dialog));
if (result == GTK_RESPONSE_OK)
{
Timespec ts;
DEBUG("deleting prices");
ts.tv_sec = gnc_date_edit_get_date (GNC_DATE_EDIT (date));
ts.tv_nsec = 0;
button = glade_xml_get_widget (xml, "delete_manual");
delete_user = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button));
button = glade_xml_get_widget (xml, "delete_last");
delete_last = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button));
gnc_pricedb_remove_old_prices(pdb_dialog->price_db, ts,
delete_user, delete_last);
}
gtk_widget_destroy(dialog);
LEAVE(" ");
}
void
gnc_sx_create_from_trans( Transaction *trans )
{
int errno;
SXFromTransInfo *sxfti = g_new0( SXFromTransInfo, 1);
sxfti->gxml = gnc_glade_xml_new(SX_GLADE_FILE,
SXFTD_DIALOG_GLADE_NAME);
sxfti->dialog = glade_xml_get_widget(sxfti->gxml,
SXFTD_DIALOG_GLADE_NAME);
sxfti->trans = trans;
sxfti->sx = xaccSchedXactionMalloc(gnc_get_current_book ());
if ( (errno = sxftd_init( sxfti )) < 0 )
{
if ( errno == SXFTD_ERRNO_OPEN_XACTION )
{
gnc_error_dialog( gnc_ui_get_toplevel(), "%s",
_( "Cannot create a Scheduled Transaction "
"from a Transaction currently "
"being edited. Please Enter the "
"Transaction before Scheduling." ) );
sxftd_close( sxfti, TRUE );
return;
}
else
{
g_error("sxftd_init: %d", errno);
}
}
gtk_widget_show_all(GTK_WIDGET(sxfti->dialog));
}
static StyleSheetDialog *
gnc_style_sheet_select_dialog_create(void)
{
StyleSheetDialog * ss = g_new0(StyleSheetDialog, 1);
GladeXML * xml;
GtkCellRenderer * renderer;
GtkTreeSelection * selection;
xml = gnc_glade_xml_new ("report.glade", "Select Style Sheet Dialog");
ss->toplevel = glade_xml_get_widget (xml, "Select Style Sheet Dialog");
ss->list_view = GTK_TREE_VIEW(glade_xml_get_widget (xml, "style_sheet_list_view"));
ss->list_store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_POINTER);
gtk_tree_view_set_model(ss->list_view, GTK_TREE_MODEL(ss->list_store));
g_object_unref(ss->list_store);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes(ss->list_view, -1,
_("Style Sheet Name"), renderer,
"text", COLUMN_NAME,
NULL);
selection = gtk_tree_view_get_selection (ss->list_view);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
g_signal_connect(ss->toplevel, "response",
G_CALLBACK(gnc_style_sheet_select_dialog_response_cb), ss);
g_signal_connect(ss->list_view, "event-after",
G_CALLBACK(gnc_style_sheet_select_dialog_event_cb), ss);
gnc_style_sheet_select_dialog_fill(ss);
gtk_widget_show_all(ss->toplevel);
return ss;
}
GncSxSinceLastRunDialog*
gnc_ui_sx_since_last_run_dialog(GncSxInstanceModel *sx_instances, GList *auto_created_txn_guids)
{
GncSxSinceLastRunDialog *dialog;
GladeXML *glade;
dialog = g_new0(GncSxSinceLastRunDialog, 1);
glade = gnc_glade_xml_new("sched-xact.glade", "since-last-run-dialog");
dialog->dialog = glade_xml_get_widget(glade, "since-last-run-dialog");
dialog->editing_model = gnc_sx_slr_tree_model_adapter_new(sx_instances);
dialog->review_created_txns_toggle = GTK_TOGGLE_BUTTON(glade_xml_get_widget(glade, "review_txn_toggle"));
dialog->created_txns = auto_created_txn_guids;
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *col;
dialog->instance_view = GTK_TREE_VIEW(glade_xml_get_widget(glade, "instance_view"));
gtk_tree_view_set_model(dialog->instance_view, GTK_TREE_MODEL(dialog->editing_model));
renderer = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new_with_attributes(_("Transaction"), renderer,
"text", SLR_MODEL_COL_NAME,
NULL);
gtk_tree_view_append_column(dialog->instance_view, col);
renderer = gtk_cell_renderer_combo_new();
g_object_set(G_OBJECT(renderer),
"model", gnc_sx_get_slr_state_model(),
"text-column", 0,
"has-entry", FALSE,
"editable", TRUE,
NULL);
g_signal_connect(G_OBJECT(renderer),
"edited",
G_CALLBACK(instance_state_changed_cb),
dialog);
col = gtk_tree_view_column_new_with_attributes(_("Status"), renderer,
"text", SLR_MODEL_COL_INSTANCE_STATE,
"visible", SLR_MODEL_COL_INSTANCE_VISIBILITY,
// you might think only "sensitive" is required to
// control the ability of the combo box to select
// a new state, but you'd be wrong.
"editable", SLR_MODEL_COL_INSTANCE_STATE_SENSITIVITY,
"sensitive", SLR_MODEL_COL_INSTANCE_STATE_SENSITIVITY,
NULL);
gtk_tree_view_append_column(dialog->instance_view, col);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer),
"editable", TRUE,
NULL);
g_signal_connect(G_OBJECT(renderer),
"edited",
G_CALLBACK(variable_value_changed_cb),
dialog);
col = gtk_tree_view_column_new_with_attributes(_("Value"), renderer,
"text", SLR_MODEL_COL_VARAIBLE_VALUE,
"visible", SLR_MODEL_COL_VARIABLE_VISIBILITY,
NULL);
gtk_tree_view_append_column(dialog->instance_view, col);
gtk_tree_view_expand_all(dialog->instance_view);
}
g_signal_connect(G_OBJECT(dialog->dialog), "response", G_CALLBACK(dialog_response_cb), dialog);
g_signal_connect(G_OBJECT(dialog->dialog), "destroy", G_CALLBACK(dialog_destroy_cb), dialog);
gnc_restore_window_size(GCONF_SECTION, GTK_WINDOW(dialog->dialog));
dialog->component_id = gnc_register_gui_component
(DIALOG_SX_SINCE_LAST_RUN_CM_CLASS, NULL, close_handler, dialog);
gnc_gui_component_set_session(dialog->component_id,
gnc_get_current_session());
gtk_widget_show_all(dialog->dialog);
return dialog;
}
void
gnc_frequency_init(GncFrequency *gf)
{
int i;
GtkVBox* vb;
GtkWidget* o;
GtkAdjustment* adj;
static const struct comboBoxTuple
{
char *name;
void (*fn)();
} comboBoxes[] =
{
{ "freq_combobox", freq_combo_changed },
{ "semimonthly_first", semimonthly_sel_changed },
{ "semimonthly_first_weekend", semimonthly_sel_changed },
{ "semimonthly_second", semimonthly_sel_changed },
{ "semimonthly_second_weekend", semimonthly_sel_changed },
{ "monthly_day", monthly_sel_changed },
{ "monthly_weekend", monthly_sel_changed },
{ NULL, NULL }
};
static const struct spinvalTuple
{
char *name;
void (*fn)();
} spinVals[] =
{
{ "daily_spin", spin_changed_helper },
{ "weekly_spin", spin_changed_helper },
{ "semimonthly_spin", spin_changed_helper },
{ "monthly_spin", spin_changed_helper },
{ NULL, NULL }
};
gf->gxml = gnc_glade_xml_new("sched-xact.glade", "gncfreq_vbox");
o = glade_xml_get_widget(gf->gxml, "gncfreq_nb");
gf->nb = GTK_NOTEBOOK(o);
o = glade_xml_get_widget(gf->gxml, "freq_combobox");
gf->freqComboBox = GTK_COMBO_BOX(o);
gf->startDate = GNC_DATE_EDIT(gnc_date_edit_new(time(NULL), FALSE, FALSE));
/* Add the new widget to the table. */
{
gint dont_expand_or_fill = 0;
GtkWidget *table = glade_xml_get_widget(gf->gxml, "gncfreq_table");
gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(gf->startDate),
1, 2, 1, 2, dont_expand_or_fill, 0,
0, 0);
}
vb = GTK_VBOX(glade_xml_get_widget(gf->gxml, "gncfreq_vbox"));
gf->vb = vb;
gtk_container_add(GTK_CONTAINER(&gf->widget), GTK_WIDGET(gf->vb));
/* initialize the combo boxes */
for (i = 0; comboBoxes[i].name != NULL; i++)
{
o = glade_xml_get_widget(gf->gxml, comboBoxes[i].name);
gtk_combo_box_set_active(GTK_COMBO_BOX(o), 0);
if (comboBoxes[i].fn != NULL)
{
g_signal_connect(o, "changed", G_CALLBACK(comboBoxes[i].fn), gf);
}
}
/* initialize the spin buttons */
for (i = 0; spinVals[i].name != NULL; i++)
{
if (spinVals[i].fn != NULL)
{
o = glade_xml_get_widget(gf->gxml, spinVals[i].name);
adj = gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(o));
g_signal_connect(adj, "value_changed", G_CALLBACK(spinVals[i].fn), gf);
}
}
/* initialize the weekly::day-of-week checkbox-selection hooks */
for (i = 0; i < 7; i++)
{
o = glade_xml_get_widget(gf->gxml, CHECKBOX_NAMES[i]);
g_signal_connect(o, "clicked",
G_CALLBACK(weekly_days_changed), gf);
}
gtk_widget_show_all(GTK_WIDGET(&gf->widget));
/* respond to start date changes */
g_signal_connect(gf->startDate, "date_changed", G_CALLBACK(start_date_changed), gf);
}
static SCM
gnc_style_sheet_new (StyleSheetDialog * ssd)
{
SCM make_ss = scm_c_eval_string("gnc:make-html-style-sheet");
SCM templates = scm_c_eval_string("(gnc:get-html-templates)");
SCM t_name = scm_c_eval_string("gnc:html-style-sheet-template-name");
SCM new_ss = SCM_BOOL_F;
GtkWidget * template_combo;
GtkTreeModel * template_model;
GtkWidget * name_entry;
gint dialog_retval;
GList *template_names = NULL;
/* get the new name for the style sheet */
GladeXML *xml = gnc_glade_xml_new ("report.glade",
"New Style Sheet Dialog");
GtkWidget * dlg = glade_xml_get_widget (xml, "New Style Sheet Dialog");
template_combo = glade_xml_get_widget (xml, "template_combobox");
name_entry = glade_xml_get_widget (xml, "name_entry");
g_assert(ssd);
/* Erase the initial dummy entry. */
template_model = gtk_combo_box_get_model(GTK_COMBO_BOX(template_combo));
gtk_list_store_clear(GTK_LIST_STORE(template_model));
/* put in the list of style sheet type names */
for (; !scm_is_null(templates); templates = SCM_CDR(templates))
{
char * str;
const char* orig_name;
SCM t = SCM_CAR(templates);
scm_dynwind_begin (0);
str = scm_to_locale_string (scm_call_1(t_name, t));
orig_name = g_strdup (str);
scm_dynwind_free (str);
scm_dynwind_end ();
/* Store the untranslated names for lookup later */
template_names = g_list_prepend (template_names, (gpointer)orig_name);
/* The displayed name should be translated */
gtk_combo_box_prepend_text(GTK_COMBO_BOX(template_combo),
_(orig_name));
}
gtk_combo_box_set_active(GTK_COMBO_BOX(template_combo), 0);
/* get the name */
gtk_window_set_transient_for (GTK_WINDOW(dlg), GTK_WINDOW(ssd->toplevel));
dialog_retval = gtk_dialog_run(GTK_DIALOG(dlg));
if (dialog_retval == GTK_RESPONSE_OK)
{
gint choice = gtk_combo_box_get_active (GTK_COMBO_BOX(template_combo));
const char *template_str = g_list_nth_data (template_names, choice);
const char *name_str = gtk_entry_get_text(GTK_ENTRY(name_entry));
if (name_str && strlen(name_str) == 0)
{
/* If the name is empty, we display an error dialog but
* refuse to create the new style sheet. */
gnc_error_dialog (ssd->toplevel, "%s", _("You must provide a name for the new style sheet."));
name_str = NULL;
}
if (template_str && name_str)
{
new_ss = scm_call_2(make_ss,
scm_makfrom0str(template_str),
scm_makfrom0str(name_str));
}
}
g_list_free (template_names);
gtk_widget_destroy(dlg);
return(new_ss);
}
GtkWidget *
gnc_column_view_edit_options(SCM options, SCM view)
{
SCM get_editor = scm_c_eval_string("gnc:report-editor-widget");
SCM ptr;
GtkWidget * editor;
GtkListStore *store;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
ptr = scm_call_1(get_editor, view);
if (ptr != SCM_BOOL_F)
{
#define FUNC_NAME "gtk_window_present"
GtkWindow * w = SWIG_MustGetPtr(ptr, SWIG_TypeQuery("_p_GtkWidget"), 1, 0);
gtk_window_present(w);
#undef FUNC_NAME
return NULL;
}
else
{
gnc_column_view_edit * r = g_new0(gnc_column_view_edit, 1);
GladeXML *xml;
r->optwin = gnc_options_dialog_new(NULL);
/* Hide the generic dialog page list. */
{
GtkWidget *dialog, *page_list;
dialog = gnc_options_dialog_widget(r->optwin);
page_list = gnc_glade_lookup_widget (dialog, "page_list");
gtk_widget_hide(page_list);
}
xml = gnc_glade_xml_new ("report.glade", "view_contents_table");
glade_xml_signal_connect_data
(xml, "gnc_column_view_edit_add_cb",
G_CALLBACK (gnc_column_view_edit_add_cb), r);
glade_xml_signal_connect_data
(xml, "gnc_column_view_edit_remove_cb",
G_CALLBACK (gnc_column_view_edit_remove_cb), r);
glade_xml_signal_connect_data
(xml, "gnc_edit_column_view_move_up_cb",
G_CALLBACK (gnc_edit_column_view_move_up_cb), r);
glade_xml_signal_connect_data
(xml, "gnc_edit_column_view_move_down_cb",
G_CALLBACK (gnc_edit_column_view_move_down_cb), r);
glade_xml_signal_connect_data
(xml, "gnc_column_view_edit_size_cb",
G_CALLBACK (gnc_column_view_edit_size_cb), r);
editor = glade_xml_get_widget (xml, "view_contents_table");
r->available = GTK_TREE_VIEW (glade_xml_get_widget (xml, "available_view"));
r->contents = GTK_TREE_VIEW (glade_xml_get_widget (xml, "contents_view"));
r->options = options;
r->view = view;
r->available_selected = 0;
r->available_list = SCM_EOL;
r->contents_selected = 0;
r->contents_list = SCM_EOL;
r->odb = gnc_option_db_new(r->options);
gnc_options_dialog_build_contents(r->optwin, r->odb);
gtk_notebook_append_page(GTK_NOTEBOOK(gnc_options_dialog_notebook
(r->optwin)),
editor,
gtk_label_new(_("Contents")));
scm_gc_protect_object(r->options);
scm_gc_protect_object(r->view);
scm_gc_protect_object(r->available_list);
scm_gc_protect_object(r->contents_list);
/* Build the 'available' view */
store = gtk_list_store_new (NUM_AVAILABLE_COLS, G_TYPE_STRING, G_TYPE_INT);
gtk_tree_view_set_model(r->available, GTK_TREE_MODEL(store));
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), AVAILABLE_COL_NAME, GTK_SORT_ASCENDING);
g_object_unref(store);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("", renderer,
"text", AVAILABLE_COL_NAME,
NULL);
gtk_tree_view_append_column(r->available, column);
selection = gtk_tree_view_get_selection(r->available);
g_signal_connect(selection, "changed",
G_CALLBACK(gnc_column_view_select_avail_cb), r);
/* Build the 'contents' view */
store = gtk_list_store_new (NUM_CONTENTS_COLS, G_TYPE_STRING, G_TYPE_INT,
G_TYPE_INT, G_TYPE_INT);
gtk_tree_view_set_model(r->contents, GTK_TREE_MODEL(store));
g_object_unref(store);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Report"), renderer,
"text", CONTENTS_COL_NAME,
NULL);
gtk_tree_view_append_column(r->contents, column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Rows"), renderer,
"text", CONTENTS_COL_REPORT_ROWS,
NULL);
gtk_tree_view_append_column(r->contents, column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Cols"), renderer,
"text", CONTENTS_COL_REPORT_COLS,
NULL);
gtk_tree_view_append_column(r->contents, column);
selection = gtk_tree_view_get_selection(r->contents);
g_signal_connect(selection, "changed",
G_CALLBACK(gnc_column_view_select_contents_cb), r);
update_display_lists(r);
gnc_options_dialog_set_apply_cb(r->optwin,
gnc_column_view_edit_apply_cb, r);
gnc_options_dialog_set_close_cb(r->optwin,
gnc_column_view_edit_close_cb, r);
gtk_widget_show(gnc_options_dialog_widget(r->optwin));
return gnc_options_dialog_widget(r->optwin);
}
}
gboolean
gnc_hbci_get_initial_password (GtkWidget *parent,
const char *windowtitle,
const char *heading,
char **password)
{
GtkWidget *dialog;
GtkWidget *heading_label;
GtkWidget *password_entry;
GtkWidget *confirm_entry;
GladeXML *xml;
gint result;
g_return_val_if_fail (password != NULL, FALSE);
xml = gnc_glade_xml_new ("hbcipass.glade", "Initial Password Dialog");
dialog = glade_xml_get_widget (xml, "Initial Password Dialog");
if (parent)
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (parent));
heading_label = glade_xml_get_widget (xml, "heading_label");
password_entry = glade_xml_get_widget (xml, "password_entry");
confirm_entry = glade_xml_get_widget (xml, "confirm_entry");
g_assert(heading_label && password_entry && confirm_entry);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), 1);
gtk_entry_set_activates_default (GTK_ENTRY (password_entry), FALSE);
gtk_entry_set_activates_default (GTK_ENTRY (confirm_entry), TRUE);
if (windowtitle)
gtk_window_set_title (GTK_WINDOW (dialog), windowtitle);
if (heading)
gtk_label_set_text (GTK_LABEL (heading_label), heading);
while (TRUE)
{
result = gtk_dialog_run (GTK_DIALOG (dialog));
if (result == 1) /* the hand-assigned response value */
{
const char *pw = gtk_entry_get_text (GTK_ENTRY (password_entry));
const char *confirm = gtk_entry_get_text (GTK_ENTRY (confirm_entry));
if (strcmp (pw, confirm) == 0)
{
*password = g_strdup(pw);
gtk_widget_destroy (GTK_WIDGET (dialog));
return TRUE;
}
}
else
break;
/* strings didn't match */
if (gnc_ok_cancel_dialog (parent, GTK_RESPONSE_OK,
_("The two passwords didn't match. "
"Please try again."))
!= GTK_RESPONSE_OK)
break;
}
*password = NULL;
gtk_widget_destroy (GTK_WIDGET (dialog));
return FALSE;
}
static void
get_input(GncGWENGui *gui, guint32 flags, const gchar *title, const gchar *text,
gchar **input, gint min_len, gint max_len)
{
GladeXML *xml;
GtkWidget *dialog;
GtkWidget *heading_label;
GtkWidget *input_entry;
GtkWidget *confirm_entry;
GtkWidget *confirm_label;
GtkWidget *remember_pin_checkbutton;
const gchar *internal_input, *internal_confirmed;
gboolean confirm = (flags & GWEN_GUI_INPUT_FLAGS_CONFIRM) != 0;
gboolean hidden = (flags & GWEN_GUI_INPUT_FLAGS_SHOW) == 0;
gboolean is_tan = (flags & GWEN_GUI_INPUT_FLAGS_TAN) != 0;
gint retval;
g_return_if_fail(input);
g_return_if_fail(max_len >= min_len && max_len > 0);
ENTER(" ");
/* Set up dialog */
xml = gnc_glade_xml_new("aqbanking.glade", "Password Dialog");
dialog = glade_xml_get_widget(xml, "Password Dialog");
g_object_set_data_full(G_OBJECT(dialog), "xml", xml, g_object_unref);
heading_label = glade_xml_get_widget(xml, "heading_label");
input_entry = glade_xml_get_widget(xml, "input_entry");
confirm_entry = glade_xml_get_widget(xml, "confirm_entry");
confirm_label = glade_xml_get_widget(xml, "confirm_label");
remember_pin_checkbutton = glade_xml_get_widget(xml, "remember_pin");
if (is_tan)
{
gtk_widget_hide(remember_pin_checkbutton);
}
else
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(remember_pin_checkbutton),
gui->cache_passwords);
}
if (gui->parent)
gtk_window_set_transient_for(GTK_WINDOW(dialog),
GTK_WINDOW(gui->parent));
if (title)
gtk_window_set_title(GTK_WINDOW(dialog), title);
if (text)
{
gchar *raw_text = strip_html(g_strdup(text));
gtk_label_set_text(GTK_LABEL(heading_label), raw_text);
g_free(raw_text);
}
if (*input)
{
gtk_entry_set_text(GTK_ENTRY(input_entry), *input);
erase_password(*input);
*input = NULL;
}
if (confirm)
{
gtk_entry_set_activates_default(GTK_ENTRY(input_entry), FALSE);
gtk_entry_set_activates_default(GTK_ENTRY(confirm_entry), TRUE);
gtk_entry_set_max_length(GTK_ENTRY(input_entry), max_len);
gtk_entry_set_max_length(GTK_ENTRY(confirm_entry), max_len);
}
else
{
gtk_entry_set_activates_default(GTK_ENTRY(input_entry), TRUE);
gtk_entry_set_max_length(GTK_ENTRY(input_entry), max_len);
gtk_widget_hide(confirm_entry);
gtk_widget_hide(confirm_label);
}
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
/* Ask the user until he enters a valid input or cancels */
while (TRUE)
{
gboolean remember_pin;
if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK)
break;
if (!is_tan)
{
/* Enable or disable the password cache */
remember_pin = gtk_toggle_button_get_active(
GTK_TOGGLE_BUTTON(remember_pin_checkbutton));
enable_password_cache(gui, remember_pin);
gnc_gconf_set_bool(GCONF_SECTION_AQBANKING, KEY_REMEMBER_PIN,
remember_pin, NULL);
}
internal_input = gtk_entry_get_text(GTK_ENTRY(input_entry));
if (strlen(internal_input) < min_len)
{
gboolean retval;
gchar *msg = g_strdup_printf(
_("The PIN needs to be at least %d characters \n"
"long. Do you want to try again?"), min_len);
retval = gnc_verify_dialog(gui->parent, TRUE, "%s", msg);
g_free(msg);
if (!retval)
break;
continue;
}
if (!confirm)
{
*input = g_strdup(internal_input);
break;
}
internal_confirmed = gtk_entry_get_text(GTK_ENTRY(confirm_entry));
if (strcmp(internal_input, internal_confirmed) == 0)
{
*input = g_strdup(internal_input);
break;
}
}
/* This trashes passwords in the entries' memory as well */
gtk_widget_destroy(dialog);
LEAVE("input %s", *input ? "non-NULL" : "NULL");
}
static void
gnc_ui_file_access( int type )
{
FileAccessWindow *faw;
GladeXML* xml;
GtkWidget* box;
GList* ds_node;
GtkButton* op;
GtkWidget* align;
GtkFileChooserWidget* fileChooser;
GtkFileChooserAction fileChooserAction = GTK_FILE_CHOOSER_ACTION_OPEN;
GList* list;
GList* node;
GtkWidget* uri_type_container;
gboolean need_access_method_file = FALSE;
gboolean need_access_method_mysql = FALSE;
gboolean need_access_method_postgres = FALSE;
gboolean need_access_method_sqlite3 = FALSE;
gboolean need_access_method_xml = FALSE;
gint access_method_index = -1;
gint active_access_method_index = -1;
const gchar* default_db;
const gchar *button_label = NULL;
g_return_if_fail( type == FILE_ACCESS_OPEN || type == FILE_ACCESS_SAVE_AS );
faw = g_new0(FileAccessWindow, 1);
g_return_if_fail( faw != NULL );
faw->type = type;
/* Open the dialog */
xml = gnc_glade_xml_new( "dialog-file-access.glade", "File Access" );
faw->dialog = glade_xml_get_widget( xml, "File Access" );
g_object_set_data_full( G_OBJECT(faw->dialog), "FileAccessWindow", faw,
g_free );
faw->frame_file = glade_xml_get_widget( xml, "frame_file" );
faw->frame_database = glade_xml_get_widget( xml, "frame_database" );
faw->tf_host = GTK_ENTRY(glade_xml_get_widget( xml, "tf_host" ));
gtk_entry_set_text( faw->tf_host, DEFAULT_HOST );
faw->tf_database = GTK_ENTRY(glade_xml_get_widget( xml, "tf_database" ));
default_db = get_default_database();
gtk_entry_set_text( faw->tf_database, default_db );
faw->tf_username = GTK_ENTRY(glade_xml_get_widget( xml, "tf_username" ));
faw->tf_password = GTK_ENTRY(glade_xml_get_widget( xml, "tf_password" ));
switch ( type )
{
case FILE_ACCESS_OPEN:
gtk_window_set_title(GTK_WINDOW(faw->dialog), _("Open..."));
button_label = "gtk-open";
fileChooserAction = GTK_FILE_CHOOSER_ACTION_OPEN;
break;
case FILE_ACCESS_SAVE_AS:
gtk_window_set_title(GTK_WINDOW(faw->dialog), _("Save As..."));
button_label = "gtk-save-as";
fileChooserAction = GTK_FILE_CHOOSER_ACTION_SAVE;
break;
}
op = GTK_BUTTON(glade_xml_get_widget( xml, "pb_op" ));
if ( op != NULL )
{
gtk_button_set_label( op, button_label );
gtk_button_set_use_stock( op, TRUE );
}
align = glade_xml_get_widget( xml, "alignment_file_chooser" );
fileChooser = GTK_FILE_CHOOSER_WIDGET(gtk_file_chooser_widget_new( fileChooserAction ));
faw->fileChooser = GTK_FILE_CHOOSER(fileChooser);
gtk_container_add( GTK_CONTAINER(align), GTK_WIDGET(fileChooser) );
g_object_connect( G_OBJECT(faw->fileChooser), "signal::file-activated",
gnc_ui_file_access_file_activated_cb, faw, NULL );
uri_type_container = glade_xml_get_widget( xml, "vb_uri_type_container" );
faw->cb_uri_type = GTK_COMBO_BOX(gtk_combo_box_new_text());
gtk_container_add( GTK_CONTAINER(uri_type_container), GTK_WIDGET(faw->cb_uri_type) );
gtk_box_set_child_packing( GTK_BOX(uri_type_container), GTK_WIDGET(faw->cb_uri_type),
/*expand*/TRUE, /*fill*/FALSE, /*padding*/0, GTK_PACK_START );
g_object_connect( G_OBJECT(faw->cb_uri_type),
"signal::changed", cb_uri_type_changed_cb, NULL,
NULL );
/* Autoconnect signals */
glade_xml_signal_autoconnect_full( xml, gnc_glade_autoconnect_full_func,
faw->dialog );
/* See what qof backends are available and add appropriate ones to the combo box */
list = qof_backend_get_registered_access_method_list();
for ( node = list; node != NULL; node = node->next )
{
const gchar* access_method = node->data;
/* For the different access methods, "mysql" and "postgres" are added if available. Access
methods "xml" and "sqlite3" are compressed to "file" if opening a file, but when saving a file,
both access methods are added. */
if ( strcmp( access_method, "mysql" ) == 0 )
{
need_access_method_mysql = TRUE;
}
else if ( strcmp( access_method, "postgres" ) == 0 )
{
need_access_method_postgres = TRUE;
}
else if ( strcmp( access_method, "xml" ) == 0 )
{
if ( type == FILE_ACCESS_OPEN )
{
need_access_method_file = TRUE;
}
else
{
need_access_method_xml = TRUE;
}
}
else if ( strcmp( access_method, "sqlite3" ) == 0 )
{
if ( type == FILE_ACCESS_OPEN )
{
need_access_method_file = TRUE;
}
else
{
need_access_method_sqlite3 = TRUE;
}
}
}
g_list_free(list);
/* Now that the set of access methods has been ascertained, add them to the list, and set the
default. */
access_method_index = -1;
if ( need_access_method_file )
{
gtk_combo_box_append_text( faw->cb_uri_type, "file" );
active_access_method_index = ++access_method_index;
}
if ( need_access_method_mysql )
{
gtk_combo_box_append_text( faw->cb_uri_type, "mysql" );
++access_method_index;
}
if ( need_access_method_postgres )
{
gtk_combo_box_append_text( faw->cb_uri_type, "postgres" );
++access_method_index;
}
if ( need_access_method_sqlite3 )
{
gtk_combo_box_append_text( faw->cb_uri_type, "sqlite3" );
active_access_method_index = ++access_method_index;
}
if ( need_access_method_xml )
{
gtk_combo_box_append_text( faw->cb_uri_type, "xml" );
++access_method_index;
// Set XML as default if it is offered (which mean we are in
// the "Save As" dialog)
active_access_method_index = access_method_index;
}
g_assert( active_access_method_index >= 0 );
/* Clean up the xml data structure when the dialog is destroyed */
g_object_set_data_full( G_OBJECT(faw->dialog), "dialog-file-access.glade",
xml, g_object_unref );
/* Run the dialog */
gtk_widget_show_all( faw->dialog );
/* Hide the frame that's not required for the active access method so either only
* the File or only the Database frame are presented. */
gtk_combo_box_set_active( faw->cb_uri_type, active_access_method_index );
set_widget_sensitivity_for_uri_type( faw, gtk_combo_box_get_active_text( faw->cb_uri_type ) );
}
static void
ap_druid_create (AcctPeriodInfo *info)
{
GladeXML *xml;
GtkWidget *w;
xml = gnc_glade_xml_new ("acctperiod.glade", "Acct Period Druid");
info->window = glade_xml_get_widget (xml, "Acct Period Druid");
info->druid = GNOME_DRUID (glade_xml_get_widget (xml, "acct_period_druid"));
gnc_druid_set_colors (info->druid);
info->start_page =
GNOME_DRUID_PAGE(glade_xml_get_widget (xml, "start page"));
info->menu_page =
GNOME_DRUID_PAGE(glade_xml_get_widget (xml, "menu page"));
info->book_page =
GNOME_DRUID_PAGE(glade_xml_get_widget (xml, "book page"));
info->finish_page =
GNOME_DRUID_PAGE(glade_xml_get_widget (xml, "finish page"));
info->close_status = -1;
/* Find the date of the earliest transaction in the book.
* Add a year minus a day as the first guess for book closing,
* and use that to set up the freq spec widget. */
info->earliest = get_earliest_in_book (gnc_get_current_book());
info->earliest_str = qof_print_date(info->earliest);
PINFO ("date of earliest transaction is %ld %s",
info->earliest, ctime (&info->earliest));
g_date_clear (&info->closing_date, 1);
g_date_set_time_t (&info->closing_date, info->earliest);
g_date_clear (&info->prev_closing_date, 1);
info->prev_closing_date = info->closing_date;
g_date_add_years (&info->closing_date, 1);
{
Recurrence *r = g_new0(Recurrence, 1);
recurrenceSet(r, 1, PERIOD_MONTH, &info->closing_date, WEEKEND_ADJ_NONE);
info->period = NULL;
info->period = g_list_append(info->period, r);
}
info->period_menu = GNC_FREQUENCY(
gnc_frequency_new_from_recurrence(info->period, &info->closing_date));
/* Change the text so that its more mainingful for this druid */
gnc_frequency_set_frequency_label_text(info->period_menu, _("Period:"));
gnc_frequency_set_date_label_text(info->period_menu, _("Closing Date:"));
/* Reparent to the correct location */
w = glade_xml_get_widget (xml, "period box");
gtk_box_pack_start (GTK_BOX (w), GTK_WIDGET (info->period_menu),
TRUE, TRUE, 0);
/* Get handles to all of the other widgets we'll need */
info->period_remarks =
GTK_LABEL (glade_xml_get_widget (xml, "remarks label"));
info->close_results =
GTK_LABEL (glade_xml_get_widget (xml, "results label"));
info->book_details =
GTK_LABEL (glade_xml_get_widget (xml, "book label"));
info->book_title =
GTK_ENTRY (glade_xml_get_widget (xml, "book title entry"));
info->book_notes =
GTK_TEXT_VIEW (glade_xml_get_widget (xml, "book notes text"));
/* generic finished/close/abort signals */
g_signal_connect (info->window, "destroy",
G_CALLBACK (ap_window_destroy_cb), info);
g_signal_connect (info->druid, "cancel",
G_CALLBACK (ap_druid_cancel), info);
g_signal_connect (info->menu_page, "prepare",
G_CALLBACK (ap_show_menu), info);
g_signal_connect (info->menu_page, "next",
G_CALLBACK (ap_validate_menu), info);
g_signal_connect (info->book_page, "prepare",
G_CALLBACK (ap_show_book), info);
g_signal_connect (info->book_page, "next",
G_CALLBACK (ap_close_period), info);
g_signal_connect (info->finish_page, "prepare",
G_CALLBACK (ap_show_done), info);
g_signal_connect (info->finish_page, "finish",
G_CALLBACK (ap_finish), info);
/* User changes the accouting period or date signals */
g_signal_connect (info->period_menu, "changed",
G_CALLBACK (ap_changed), info);
}
void
gnc_ab_initial_druid(void)
{
ABInitialInfo *info;
GladeXML *xml;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
gint component_id;
info = g_new0(ABInitialInfo, 1);
xml = gnc_glade_xml_new("aqbanking.glade", "AqBanking Init Druid");
info->window = glade_xml_get_widget(xml, "AqBanking Init Druid");
g_object_set_data_full(G_OBJECT(info->window), "xml", xml, g_object_unref);
glade_xml_signal_autoconnect_full(xml, gnc_glade_autoconnect_full_func,
info);
info->druid = glade_xml_get_widget(xml, "ab_init_druid");
gnc_druid_set_colors(GNOME_DRUID(info->druid));
info->api = gnc_AB_BANKING_new();
info->deferred_info = NULL;
info->gnc_hash = NULL;
info->match_page_prepared = FALSE;
info->account_view =
GTK_TREE_VIEW(glade_xml_get_widget(xml, "account_page_view"));
info->account_store = gtk_list_store_new(NUM_ACCOUNT_LIST_COLS,
G_TYPE_INT, G_TYPE_STRING,
G_TYPE_POINTER, G_TYPE_STRING,
G_TYPE_BOOLEAN);
gtk_tree_view_set_model(info->account_view,
GTK_TREE_MODEL(info->account_store));
g_object_unref(info->account_store);
column = gtk_tree_view_column_new_with_attributes(
_("Online Banking Account Name"), gtk_cell_renderer_text_new(),
"text", ACCOUNT_LIST_COL_AB_NAME, (gchar*) NULL);
gtk_tree_view_append_column(info->account_view, column);
column = gtk_tree_view_column_new_with_attributes(
_("GnuCash Account Name"), gtk_cell_renderer_text_new(),
"text", ACCOUNT_LIST_COL_GNC_NAME, (gchar*) NULL);
gtk_tree_view_column_set_expand(column, TRUE);
gtk_tree_view_append_column(info->account_view, column);
column = gtk_tree_view_column_new_with_attributes(
_("New?"), gtk_cell_renderer_toggle_new(),
"active", ACCOUNT_LIST_COL_CHECKED, (gchar*) NULL);
gtk_tree_view_append_column(info->account_view, column);
selection = gtk_tree_view_get_selection(info->account_view);
g_signal_connect(selection, "changed",
G_CALLBACK(account_list_changed_cb), info);
component_id = gnc_register_gui_component(DRUID_AB_INITIAL_CM_CLASS,
NULL, cm_close_handler, info);
gnc_gui_component_set_session(component_id, gnc_get_current_session());
gtk_widget_show(info->window);
}
gboolean
gnc_ab_enter_daterange(GtkWidget *parent,
const char *heading,
Timespec *from_date,
gboolean *last_retv_date,
gboolean *first_possible_date,
Timespec *to_date,
gboolean *to_now)
{
GladeXML *xml;
GtkWidget *dialog;
GtkWidget *heading_label;
GtkWidget *first_button;
GtkWidget *last_retrieval_button;
GtkWidget *now_button;
DaterangeInfo info;
gint result;
xml = gnc_glade_xml_new("aqbanking.glade", "Date Range Dialog");
dialog = glade_xml_get_widget(xml, "Date Range Dialog");
g_object_set_data_full(G_OBJECT(dialog), "xml", xml, g_object_unref);
glade_xml_signal_autoconnect_full(xml, gnc_glade_autoconnect_full_func,
&info);
if (parent)
gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(parent));
heading_label = glade_xml_get_widget(xml, "heading_label");
first_button = glade_xml_get_widget(xml, "first_button");
last_retrieval_button = glade_xml_get_widget(xml, "last_retrieval_button");
info.enter_from_button = glade_xml_get_widget(xml, "enter_from_button");
now_button = glade_xml_get_widget(xml, "now_button");
info.enter_to_button = glade_xml_get_widget(xml, "enter_to_button");
info.from_dateedit = gnc_date_edit_new_ts(*from_date, FALSE, FALSE);
gtk_container_add(GTK_CONTAINER(glade_xml_get_widget(xml, "enter_from_box")),
info.from_dateedit);
gtk_widget_show(info.from_dateedit);
info.to_dateedit = gnc_date_edit_new_ts(*to_date, FALSE, FALSE);
gtk_container_add(GTK_CONTAINER(glade_xml_get_widget(xml, "enter_to_box")),
info.to_dateedit);
gtk_widget_show(info.to_dateedit);
if (*last_retv_date)
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(last_retrieval_button),
TRUE);
}
else
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(first_button), TRUE);
gtk_widget_set_sensitive(last_retrieval_button, FALSE);
}
gtk_widget_set_sensitive(info.from_dateedit, FALSE);
gtk_widget_set_sensitive(info.to_dateedit, FALSE);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
if (heading)
gtk_label_set_text(GTK_LABEL(heading_label), heading);
gtk_widget_show(dialog);
result = gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_hide(dialog);
if (result == GTK_RESPONSE_OK)
{
*from_date = gnc_date_edit_get_date_ts(
GNC_DATE_EDIT(info.from_dateedit));
*last_retv_date = gtk_toggle_button_get_active(
GTK_TOGGLE_BUTTON(last_retrieval_button));
*first_possible_date = gtk_toggle_button_get_active(
GTK_TOGGLE_BUTTON(first_button));
*to_date = gnc_date_edit_get_date_ts(
GNC_DATE_EDIT(info.to_dateedit));
*to_now = gtk_toggle_button_get_active(
GTK_TOGGLE_BUTTON(now_button));
}
gtk_widget_destroy(dialog);
return result == GTK_RESPONSE_OK;
}
