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; }