static void on_expression_toggle (GtkToggleButton *button, gpointer data) { struct compute_dialog *cd = data; GtkWidget *entry = get_widget_assert (cd->xml, "type-and-label-label-entry"); if ( gtk_toggle_button_get_active (button)) { gtk_entry_set_text (GTK_ENTRY (entry), ""); gtk_widget_set_sensitive (entry, FALSE); } else { const char *label; struct variable *target_var; const gchar *target_name = gtk_entry_get_text (GTK_ENTRY (get_widget_assert (cd->xml, "compute-entry1"))); target_var = psppire_dict_lookup_var (cd->dict, target_name); if ( target_var ) { label = var_get_label (target_var); if ( label ) gtk_entry_set_text (GTK_ENTRY (entry), label); } else gtk_entry_set_text (GTK_ENTRY (entry), ""); gtk_widget_set_sensitive (entry, TRUE); } }
static void refresh (GObject *obj, const struct compute_dialog *cd) { GtkTextIter start, end; GtkWidget *target = get_widget_assert (cd->xml, "compute-entry1"); GtkWidget *syntax_area = get_widget_assert (cd->xml, "compute-textview1"); GtkWidget *varlist = get_widget_assert (cd->xml, "compute-treeview1"); GtkWidget *funclist = get_widget_assert (cd->xml, "compute-treeview2"); GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (syntax_area)); GtkTreeSelection *selection; /* Clear the target variable entry box */ gtk_entry_set_text (GTK_ENTRY (target), ""); g_signal_emit_by_name (target, "changed"); /* Clear the syntax area textbuffer */ gtk_text_buffer_get_start_iter (buffer, &start); gtk_text_buffer_get_end_iter (buffer, &end); gtk_text_buffer_delete (buffer, &start, &end); /* Unselect all items in the treeview */ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (varlist)); gtk_tree_selection_unselect_all (selection); /* And the other one */ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (funclist)); gtk_tree_selection_unselect_all (selection); }
/* FLIP /VARIABLES=var_list /NEWNAMES=var_name. */ static gchar * generate_syntax (PsppireDict *dict, GtkBuilder *xml) { const gchar *text; GString *string = g_string_new ("FLIP"); gchar *syntax ; GtkWidget *dest = get_widget_assert (xml, "variables-treeview"); GtkWidget *entry = get_widget_assert (xml, "new-name-entry"); g_string_append (string, " /VARIABLES = "); psppire_var_view_append_names (PSPPIRE_VAR_VIEW (dest), 0, string); text = gtk_entry_get_text (GTK_ENTRY (entry)); if ( text) g_string_append_printf (string, " /NEWNAME = %s", text); g_string_append (string, "."); syntax = string->str; g_string_free (string, FALSE); return syntax; }
static gchar * generate_syntax (const struct select_cases_dialog *scd) { /* In the simple case, all we need to do is cancel any existing filter */ if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (get_widget_assert (scd->xml, "radiobutton-all")))) { return g_strdup ("FILTER OFF.\n"); } /* Are we filtering or deleting ? */ if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (get_widget_assert (scd->xml, "radiobutton-delete")))) { return generate_syntax_delete (scd); } else { return generate_syntax_filter (scd); } }
static struct tt_groups_dialog * tt_groups_dialog_create (GtkBuilder *xml, GtkWindow *parent) { struct tt_groups_dialog *grps = xmalloc (sizeof (*grps)); grps->group_defn = GROUPS_UNDEF; grps->dialog = get_widget_assert (xml, "define-groups-dialog"); grps->table1 = get_widget_assert (xml, "table1"); grps->table2 = get_widget_assert (xml, "table2"); grps->label = get_widget_assert (xml, "label4"); grps->hbox1 = get_widget_assert (xml, "hbox1"); grps->grp_entry[0] = get_widget_assert (xml, "group1-entry"); grps->grp_entry[1] = get_widget_assert (xml, "group2-entry"); grps->cut_point_entry = get_widget_assert (xml, "cut-point-entry"); grps->cut_point_toggle_button = get_widget_assert (xml, "radiobutton4"); grps->values_toggle_button = get_widget_assert (xml, "radiobutton3"); g_object_ref (grps->table1); g_object_ref (grps->table2); g_signal_connect (grps->values_toggle_button, "toggled", G_CALLBACK (set_group_criterion_type), grps); gtk_window_set_transient_for (GTK_WINDOW (grps->dialog), parent); grps->val[0] = xstrdup (""); grps->val[1] = xstrdup (""); return grps; }
static char * generate_syntax (const struct comment_dialog *cd) { gint i; GString *str; gchar *text; GtkWidget *tv = get_widget_assert (cd->xml, "comments-textview1"); GtkWidget *check = get_widget_assert (cd->xml, "comments-checkbutton1"); GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (tv)); str = g_string_new ("\n* Data File Comments.\n\n"); if (dict_get_documents (cd->dict->dict) != NULL) g_string_append (str, "DROP DOCUMENTS.\n"); g_string_append (str, "ADD DOCUMENT\n"); for (i = 0 ; i < gtk_text_buffer_get_line_count (buffer) ; ++i ) { struct string tmp; GtkTextIter start; char *line; gtk_text_buffer_get_iter_at_line (buffer, &start, i); if (gtk_text_iter_ends_line (&start)) line = g_strdup (""); else { GtkTextIter end = start; gtk_text_iter_forward_to_line_end (&end); line = gtk_text_buffer_get_text (buffer, &start, &end, FALSE); } ds_init_empty (&tmp); syntax_gen_string (&tmp, ss_cstr (line)); g_free (line); g_string_append_printf (str, " %s\n", ds_cstr (&tmp)); ds_destroy (&tmp); } g_string_append (str, " .\n"); if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (check))) g_string_append (str, "DISPLAY DOCUMENTS.\n"); text = str->str; g_string_free (str, FALSE); return text; }
static void refresh (PsppireDialog *dialog, gpointer data) { GtkBuilder *xml = data; GtkWidget *dest = get_widget_assert (xml, "variables-treeview"); GtkWidget *entry = get_widget_assert (xml, "new-name-entry"); GtkTreeModel *dmodel = gtk_tree_view_get_model (GTK_TREE_VIEW (dest)); gtk_list_store_clear (GTK_LIST_STORE (dmodel)); gtk_entry_set_text (GTK_ENTRY (entry), ""); }
static void on_target_change (GObject *obj, struct compute_dialog *cd) { GtkWidget *target = get_widget_assert (cd->xml, "compute-entry1"); GtkWidget *type_and_label = get_widget_assert (cd->xml, "compute-button1"); const gchar *var_name = gtk_entry_get_text (GTK_ENTRY (target)); gboolean valid = var_name && strcmp ("", var_name); gtk_widget_set_sensitive (type_and_label, valid); }
/* Resets IA's sheet_spec page to its initial state. */ void reset_sheet_spec_page (struct import_assistant *ia) { GtkBuilder *builder = ia->asst.builder; GtkWidget *sheet_entry = get_widget_assert (builder, "sheet-entry"); GtkWidget *readnames_checkbox = get_widget_assert (builder, "readnames-checkbox"); gtk_combo_box_set_active (GTK_COMBO_BOX (sheet_entry), 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (readnames_checkbox), FALSE); }
void transpose_dialog (PsppireDataWindow *de) { gint response ; PsppireDict *dict = NULL; GtkBuilder *xml = builder_new ("psppire.ui"); PsppireVarStore *vs = NULL; GtkWidget *dialog = get_widget_assert (xml, "transpose-dialog"); GtkWidget *source = get_widget_assert (xml, "source-treeview"); GtkWidget *selector2 = get_widget_assert (xml, "psppire-selector3"); g_object_get (de->data_editor, "var-store", &vs, NULL); g_object_get (vs, "dictionary", &dict, NULL); g_object_set (source, "model", dict, NULL); psppire_selector_set_filter_func (PSPPIRE_SELECTOR (selector2), is_currently_in_entry); g_signal_connect (dialog, "refresh", G_CALLBACK (refresh), xml); gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (de)); psppire_dialog_set_valid_predicate (PSPPIRE_DIALOG (dialog), dialog_state_valid, xml); response = psppire_dialog_run (PSPPIRE_DIALOG (dialog)); switch (response) { case GTK_RESPONSE_OK: g_free (execute_syntax_string (de, generate_syntax (dict, xml))); break; case PSPPIRE_RESPONSE_PASTE: { gchar *syntax = generate_syntax (dict, xml); paste_syntax_to_window (syntax); g_free (syntax); } break; default: break; } g_object_unref (xml); }
static void run_type_label_dialog (GtkButton *b, gpointer data) { struct compute_dialog *cd = data; gint response; GtkWidget *subdialog = get_widget_assert (cd->xml, "type-and-label-dialog"); GtkWidget *dialog = get_widget_assert (cd->xml, "compute-variable-dialog"); gtk_window_set_transient_for (GTK_WINDOW (subdialog), GTK_WINDOW (dialog)); reset_type_label_dialog (cd); response = psppire_dialog_run (PSPPIRE_DIALOG (subdialog)); if ( response == PSPPIRE_RESPONSE_CONTINUE) cd->use_type = TRUE; }
struct paired_samples_dialog * two_sample_dialog_create (PsppireDataWindow *de) { GtkWidget *dict_view ; GtkWidget *selector ; struct paired_samples_dialog *tt_d = g_malloc (sizeof *tt_d); PsppireVarStore *vs = NULL; tt_d->xml = builder_new ("paired-samples.ui"); dict_view = get_widget_assert (tt_d->xml, "paired-samples-t-test-treeview1"); selector = get_widget_assert (tt_d->xml, "psppire-selector3"); tt_d->dialog = get_widget_assert (tt_d->xml, "t-test-paired-samples-dialog"); g_object_get (de->data_editor, "var-store", &vs, NULL); g_object_get (vs, "dictionary", &tt_d->dict, NULL); tt_d->pairs_treeview = get_widget_assert (tt_d->xml, "paired-samples-t-test-treeview2"); gtk_window_set_transient_for (GTK_WINDOW (tt_d->dialog), GTK_WINDOW (de)); g_object_set (dict_view, "model", tt_d->dict, "predicate", var_is_numeric, NULL); tt_d->list_store = gtk_tree_view_get_model (GTK_TREE_VIEW (tt_d->pairs_treeview)); psppire_selector_set_select_func (PSPPIRE_SELECTOR (selector), select_as_pair_member, tt_d); g_signal_connect_swapped (tt_d->dialog, "refresh", G_CALLBACK (refresh), tt_d); psppire_dialog_set_valid_predicate (PSPPIRE_DIALOG (tt_d->dialog), dialog_state_valid, tt_d); return tt_d; }
/* Return TRUE if the dialog box's widgets' state are such that clicking OK might not result in erroneous syntax being generated */ static gboolean contents_plausible (gpointer data) { struct compute_dialog *cd = data; GtkWidget *target = get_widget_assert (cd->xml, "compute-entry1"); GtkWidget *syntax_area = get_widget_assert (cd->xml, "compute-textview1"); GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (syntax_area)); if ( 0 == strcmp ("", gtk_entry_get_text (GTK_ENTRY (target)))) return FALSE; if ( gtk_text_buffer_get_char_count (buffer) == 0 ) return FALSE; return TRUE; }
static gboolean dialog_state_valid (gpointer data) { GtkBuilder *xml = data; GtkWidget *tv = get_widget_assert (xml, "variables-treeview"); GtkWidget *entry = get_widget_assert (xml, "new-name-entry"); GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (tv)); gint n_rows = gtk_tree_model_iter_n_children (model, NULL); if ( n_rows == 0 ) return FALSE; if ( 0 == strcmp ("", gtk_entry_get_text (GTK_ENTRY (entry)))) return FALSE; return TRUE; }
static void erase (PsppireKeypad *kp, gpointer data) { GtkBuilder *xml = data; GtkWidget *rhs = get_widget_assert (xml, "compute-textview1"); GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (rhs)); erase_selection (buffer); }
/* Initializes IA's sheet_spec substructure. */ struct sheet_spec_page * sheet_spec_page_create (struct import_assistant *ia) { GtkBuilder *builder = ia->asst.builder; struct sheet_spec_page *p = xzalloc (sizeof (*p)); GtkWidget *combo_box = get_widget_assert (builder, "sheet-entry"); GtkCellRenderer *renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), renderer, "text", 0, NULL); g_signal_connect (combo_box, "changed", G_CALLBACK (on_sheet_combo_changed), ia); add_page_to_assistant (ia, get_widget_assert (builder, "Sheet"), GTK_ASSISTANT_PAGE_INTRO); return p; }
/* Pops up the Ks_One_Sample dialog box */ void ks_one_sample_dialog (PsppireDataWindow *dw) { struct ks_one_sample fd; gint response; PsppireVarStore *vs; GtkWidget *dialog ; GtkWidget *source ; fd.xml = builder_new ("ks-one-sample.ui"); dialog = get_widget_assert (fd.xml, "ks-one-sample-dialog"); source = get_widget_assert (fd.xml, "dict-view"); fd.cb[CB_NORMAL] = get_widget_assert (fd.xml, "checkbutton-normal"); fd.cb[CB_POISSON] = get_widget_assert (fd.xml, "checkbutton-poisson"); fd.cb[CB_UNIFORM] = get_widget_assert (fd.xml, "checkbutton-uniform"); fd.cb[CB_EXPONENTIAL] = get_widget_assert (fd.xml, "checkbutton-exp"); fd.de = dw; g_signal_connect_swapped (dialog, "refresh", G_CALLBACK (refresh), &fd); fd.variables = get_widget_assert (fd.xml, "psppire-var-view1"); g_object_get (fd.de->data_editor, "var-store", &vs, NULL); gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (fd.de)); g_object_get (vs, "dictionary", &fd.dict, NULL); g_object_set (source, "model", fd.dict, "predicate", var_is_numeric, NULL); psppire_dialog_set_valid_predicate (PSPPIRE_DIALOG (dialog), dialog_state_valid, &fd); response = psppire_dialog_run (PSPPIRE_DIALOG (dialog)); switch (response) { case GTK_RESPONSE_OK: g_free (execute_syntax_string (dw, generate_syntax (&fd))); break; case PSPPIRE_RESPONSE_PASTE: g_free (paste_syntax_to_window (generate_syntax (&fd))); break; default: break; } g_object_unref (fd.xml); }
static void refresh (PsppireDialog *dialog, const struct comment_dialog *cd) { gint i; GtkWidget *tv = get_widget_assert (cd->xml, "comments-textview1"); GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (tv)); gtk_text_buffer_set_text (buffer, "", 0); for ( i = 0 ; i < dict_get_document_line_cnt (cd->dict->dict); ++i ) add_line_to_buffer (buffer, dict_get_document_line (cd->dict->dict, i)); }
static void psppire_dialog_action_sort_activate (GtkAction *a) { PsppireDialogAction *pda = PSPPIRE_DIALOG_ACTION (a); PsppireDialogActionSort *act = PSPPIRE_DIALOG_ACTION_SORT (a); GtkBuilder *xml = builder_new ("sort.ui"); pda->dialog = get_widget_assert (xml, "sort-cases-dialog"); pda->source = get_widget_assert (xml, "sort-cases-treeview1"); act->variables = get_widget_assert (xml, "sort-cases-treeview2"); act->ascending = get_widget_assert (xml, "sort-cases-radiobutton0"); psppire_dialog_action_set_refresh (pda, reset); psppire_dialog_action_set_valid_predicate (pda, dialog_state_valid); if (PSPPIRE_DIALOG_ACTION_CLASS (psppire_dialog_action_sort_parent_class)->activate) PSPPIRE_DIALOG_ACTION_CLASS (psppire_dialog_action_sort_parent_class)->activate (pda); }
static void on_sheet_combo_changed (GtkComboBox *cb, struct import_assistant *ia) { GtkTreeIter iter; gchar *range = NULL; GtkTreeModel *model = gtk_combo_box_get_model (cb); GtkBuilder *builder = ia->asst.builder; GtkWidget *range_entry = get_widget_assert (builder, "cell-range-entry"); gtk_combo_box_get_active_iter (cb, &iter); gtk_tree_model_get (model, &iter, PSPPIRE_SPREADSHEET_MODEL_COL_RANGE, &range, -1); gtk_entry_set_text (GTK_ENTRY (range_entry), range ? range : ""); g_free (range); }
static void refresh (struct tt_indep_samples_dialog *ttd) { GtkWidget *tv = get_widget_assert (ttd->xml, "indep-samples-t-test-treeview2"); GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (tv)); gtk_entry_set_text (GTK_ENTRY (ttd->groups_entry), ""); gtk_list_store_clear (GTK_LIST_STORE (model)); gtk_widget_set_sensitive (ttd->define_groups_button, FALSE); }
/* Initializes IA's first_line substructure. */ struct first_line_page * first_line_page_create (struct import_assistant *ia) { struct first_line_page *p = xzalloc (sizeof *p); GtkBuilder *builder = ia->asst.builder; p->page = add_page_to_assistant (ia, get_widget_assert (builder, "FirstLine"), GTK_ASSISTANT_PAGE_CONTENT); gtk_widget_destroy (get_widget_assert (builder, "first-line")); p->tree_view = create_lines_tree_view ( GTK_CONTAINER (get_widget_assert (builder, "first-line-scroller")), ia); p->variable_names_cb = get_widget_assert (builder, "variable-names"); pspp_sheet_selection_set_mode ( pspp_sheet_view_get_selection (PSPP_SHEET_VIEW (p->tree_view)), PSPP_SHEET_SELECTION_BROWSE); pspp_sheet_view_set_rubber_banding (PSPP_SHEET_VIEW (p->tree_view), TRUE); g_signal_connect (pspp_sheet_view_get_selection (PSPP_SHEET_VIEW (p->tree_view)), "changed", G_CALLBACK (on_first_line_change), ia); g_signal_connect (p->variable_names_cb, "toggled", G_CALLBACK (on_variable_names_cb_toggle), ia); return p; }
static void psppire_dialog_action_reliability_activate (GtkAction *a) { PsppireDialogAction *pda = PSPPIRE_DIALOG_ACTION (a); PsppireDialogActionReliability *act = PSPPIRE_DIALOG_ACTION_RELIABILITY (a); GtkTreeModel *liststore ; GtkBuilder *xml = builder_new ("reliability.ui"); pda->dialog = get_widget_assert (xml, "reliability-dialog"); pda->source = get_widget_assert (xml, "dict-view"); act->variables = get_widget_assert (xml, "treeview2"); act->split_point_hbox = get_widget_assert (xml, "split-point-hbox"); act->variables = get_widget_assert (xml, "treeview2"); act->model_combo = get_widget_assert (xml, "combobox1"); act->split_spinbutton = get_widget_assert (xml, "spinbutton1"); liststore = gtk_tree_view_get_model (GTK_TREE_VIEW (act->variables)); act->scale_if_item_deleted_checkbutton = get_widget_assert (xml, "totals-checkbutton"); g_signal_connect_swapped (act->model_combo, "changed", G_CALLBACK (update_split_control), pda); g_signal_connect_swapped (liststore, "row-inserted", G_CALLBACK (update_split_control), pda); g_signal_connect_swapped (liststore, "row-deleted", G_CALLBACK (update_split_control), pda); psppire_dialog_action_set_refresh (pda, refresh); psppire_dialog_action_set_valid_predicate (pda, dialog_state_valid); if (PSPPIRE_DIALOG_ACTION_CLASS (psppire_dialog_action_reliability_parent_class)->activate) PSPPIRE_DIALOG_ACTION_CLASS (psppire_dialog_action_reliability_parent_class)->activate (pda); g_object_unref (xml); }
char * sheet_spec_gen_syntax (const struct import_assistant *ia) { const struct sheet_spec_page *ssp = ia->sheet_spec; GtkBuilder *builder = ia->asst.builder; GtkWidget *range_entry = get_widget_assert (builder, "cell-range-entry"); const gchar *range = gtk_entry_get_text (GTK_ENTRY (range_entry)); struct string s = DS_EMPTY_INITIALIZER; syntax_gen_pspp (&s, "GET DATA" "\n /TYPE=%ss" "\n /FILE=%sq" "\n /SHEET=index %d" "\n /READNAMES=%ss", (ia->spreadsheet->type == SPREADSHEET_GNUMERIC) ? "GNM" : "ODS", ia->file.file_name, ssp->opts.sheet_index, ssp->opts.read_names ? "ON" : "OFF"); if (range && 0 != strcmp ("", range)) { syntax_gen_pspp (&s, "\n /CELLRANGE=RANGE %sq", range); } else { syntax_gen_pspp (&s, "\n /CELLRANGE=FULL"); } syntax_gen_pspp (&s, "."); return ds_cstr (&s); }
static void range_subdialog (GtkButton *b, gpointer data) { gint response; struct select_cases_dialog *scd = data; gint n_cases = psppire_data_store_get_case_count (scd->data_store); GtkWidget *parent_dialog = get_widget_assert (scd->xml, "select-cases-dialog"); GtkWidget *dialog = get_widget_assert (scd->xml, "select-cases-range-dialog"); GtkWidget *first = get_widget_assert (scd->xml, "range-dialog-first"); GtkWidget *last = get_widget_assert (scd->xml, "range-dialog-last"); gtk_spin_button_set_range (GTK_SPIN_BUTTON (last), 1, n_cases); gtk_spin_button_set_range (GTK_SPIN_BUTTON (first), 1, n_cases); gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (parent_dialog)); response = psppire_dialog_run (PSPPIRE_DIALOG (dialog)); if ( response == PSPPIRE_RESPONSE_CONTINUE) { GtkWidget *first = get_widget_assert (scd->xml, "range-dialog-first"); GtkWidget *last = get_widget_assert (scd->xml, "range-dialog-last"); GtkWidget *l1 = get_widget_assert (scd->xml, "range-sample-label"); gchar *text = widget_printf (_("%d thru %d"), first, last); gtk_label_set_text (GTK_LABEL (l1), text); g_free (text); } }
static gboolean dialog_state_valid (gpointer data) { struct tt_indep_samples_dialog *tt_d = data; GtkWidget *tv_vars = get_widget_assert (tt_d->xml, "indep-samples-t-test-treeview2"); GtkTreeModel *vars = gtk_tree_view_get_model (GTK_TREE_VIEW (tv_vars)); GtkTreeIter notused; if ( 0 == strcmp ("", gtk_entry_get_text (GTK_ENTRY (tt_d->groups_entry)))) return FALSE; if ( 0 == gtk_tree_model_get_iter_first (vars, ¬used)) return FALSE; if ( tt_d->grps->group_defn == GROUPS_UNDEF) return FALSE; return TRUE; }
static void on_keypad_button (PsppireKeypad *kp, const gchar *syntax, gpointer data) { GtkBuilder *xml = data; GtkWidget *rhs = get_widget_assert (xml, "compute-textview1"); GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (rhs)); erase_selection (buffer); gtk_text_buffer_insert_at_cursor (buffer, syntax, strlen (syntax)); if (0 == strcmp (syntax, "()")) { GtkTextIter iter; GtkTextMark *cursor = gtk_text_buffer_get_insert (buffer); gtk_text_buffer_get_iter_at_mark (buffer, &iter, cursor); gtk_text_iter_backward_cursor_position (&iter); gtk_text_buffer_move_mark (buffer, cursor, &iter); } }
static void sample_subdialog (GtkButton *b, gpointer data) { gint response; struct select_cases_dialog *scd = data; gint case_count = psppire_data_store_get_case_count (scd->data_store); GtkWidget *parent_dialog = get_widget_assert (scd->xml, "select-cases-dialog"); GtkWidget *dialog = get_widget_assert (scd->xml, "select-cases-random-sample-dialog"); GtkWidget *percent = get_widget_assert (scd->xml, "radiobutton-sample-percent"); GtkWidget *sample_n_cases = get_widget_assert (scd->xml, "radiobutton-sample-n-cases"); GtkWidget *table = get_widget_assert (scd->xml, "select-cases-random-sample-table"); if ( ! scd->hbox1 ) { scd->hbox1 = psppire_scanf_new (gettext (label1), &scd->spinbutton); gtk_widget_show (scd->hbox1); gtk_table_attach_defaults (GTK_TABLE (table), scd->hbox1, 1, 2, 0, 1); g_signal_connect (percent, "toggled", G_CALLBACK (set_sensitivity_from_toggle), scd->hbox1); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (percent), TRUE); } if ( ! scd->hbox2 ) { scd->hbox2 = psppire_scanf_new (gettext (label2), &scd->spinbutton1, &scd->spinbutton2); gtk_spin_button_set_range (GTK_SPIN_BUTTON (scd->spinbutton1), 1, case_count); gtk_spin_button_set_range (GTK_SPIN_BUTTON (scd->spinbutton2), 1, case_count); gtk_widget_show (scd->hbox2); gtk_widget_set_sensitive (scd->hbox2, FALSE); gtk_table_attach_defaults (GTK_TABLE (table), scd->hbox2, 1, 2, 1, 2); g_signal_connect (sample_n_cases, "toggled", G_CALLBACK (set_sensitivity_from_toggle), scd->hbox2); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (sample_n_cases), FALSE); } gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (parent_dialog)); response = psppire_dialog_run (PSPPIRE_DIALOG (dialog)); if ( response != PSPPIRE_RESPONSE_CONTINUE) { g_signal_handlers_disconnect_by_func (G_OBJECT (percent), G_CALLBACK (set_sensitivity_from_toggle), scd->hbox1); g_signal_handlers_disconnect_by_func (G_OBJECT (sample_n_cases), G_CALLBACK (set_sensitivity_from_toggle), scd->hbox2); gtk_widget_destroy(scd->hbox1); gtk_widget_destroy(scd->hbox2); scd->hbox1 = scd->hbox2 = NULL; } else { gchar *text; GtkWidget *l0 = get_widget_assert (scd->xml, "random-sample-label"); if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (percent))) { text = widget_printf (gettext(label1), scd->spinbutton); gtk_label_set_text (GTK_LABEL (l0), text); } else { text = widget_printf (gettext(label2), scd->spinbutton1, scd->spinbutton2); gtk_label_set_text (GTK_LABEL (l0), text); } g_free (text); } }
static gchar * generate_syntax_delete (const struct select_cases_dialog *scd) { gchar *text = NULL; GString *string = NULL; if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (get_widget_assert (scd->xml, "radiobutton-all")))) { return xstrdup ("\n"); } string = g_string_new (""); if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (get_widget_assert (scd->xml, "radiobutton-sample")))) { GtkWidget *random_sample = get_widget_assert (scd->xml, "radiobutton-sample-percent"); g_string_append (string, "SAMPLE "); if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (random_sample))) { const double percentage = gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->spinbutton)); g_string_append_printf (string, "%g.", percentage / 100.0); } else { const gint n_cases = gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->spinbutton1)); const gint from_n_cases = gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->spinbutton2)); g_string_append_printf (string, "%d FROM %d .", n_cases, from_n_cases); } } else if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (get_widget_assert (scd->xml, "radiobutton-range")))) { GtkSpinButton *first = GTK_SPIN_BUTTON (get_widget_assert (scd->xml, "range-dialog-first")); GtkSpinButton *last = GTK_SPIN_BUTTON (get_widget_assert (scd->xml, "range-dialog-last")); g_string_append_printf (string, "COMPUTE filter_$ = ($CASENUM >= %ld " "AND $CASENUM <= %ld).\n", (long) gtk_spin_button_get_value (first), (long) gtk_spin_button_get_value (last) ); g_string_append (string, "EXECUTE.\n"); g_string_append_printf (string, "SELECT IF filter_$.\n"); } else if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (get_widget_assert (scd->xml, "radiobutton-filter-variable")))) { GtkEntry *entry = GTK_ENTRY (get_widget_assert (scd->xml, "filter-variable-entry")); g_string_append_printf (string, "SELECT IF (%s <> 0).", gtk_entry_get_text (entry)); } g_string_append (string, "\n"); text = string->str; g_string_free (string, FALSE); return text; }
static gchar * generate_syntax_filter (const struct select_cases_dialog *scd) { gchar *text = NULL; GString *string = g_string_new (""); const gchar *filter = "filter_$"; const gchar key[]="case_$"; if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (get_widget_assert (scd->xml, "radiobutton-range")))) { GtkSpinButton *first = GTK_SPIN_BUTTON (get_widget_assert (scd->xml, "range-dialog-first")); GtkSpinButton *last = GTK_SPIN_BUTTON (get_widget_assert (scd->xml, "range-dialog-last")); g_string_append_printf (string, "COMPUTE filter_$ = ($CASENUM >= %ld " "AND $CASENUM <= %ld).\n", (long) gtk_spin_button_get_value (first), (long) gtk_spin_button_get_value (last) ); g_string_append (string, "EXECUTE.\n"); } else if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (get_widget_assert (scd->xml, "radiobutton-sample")))) { GtkWidget *random_sample = get_widget_assert (scd->xml, "radiobutton-sample-percent"); if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (random_sample))) { const double percentage = gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->spinbutton)); g_string_append_printf (string, "COMPUTE %s = RV.UNIFORM (0,1) < %g.\n", filter, percentage / 100.0 ); } else { const gint n_cases = gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->spinbutton1)); const gint from_n_cases = gtk_spin_button_get_value (GTK_SPIN_BUTTON (scd->spinbutton2)); const gchar ranvar[]="rv_$"; g_string_append_printf (string, "COMPUTE %s = $CASENUM.\n", key); g_string_append_printf (string, "COMPUTE %s = %s > %d.\n", filter, key, from_n_cases); g_string_append_printf (string, "COMPUTE %s = RV.UNIFORM (0, 1).\n", ranvar); g_string_append_printf (string, "SORT BY %s, %s.\n", filter, ranvar); g_string_append (string, "EXECUTE.\n"); g_string_append_printf (string, "COMPUTE %s = $CASENUM.\n", filter ); g_string_append_printf (string, "COMPUTE %s = %s <= %d\n", filter, filter, n_cases ); g_string_append (string, "EXECUTE.\n"); g_string_append_printf (string, "SORT BY %s.\n", key); g_string_append_printf (string, "DELETE VARIABLES %s, %s.\n", key, ranvar); } g_string_append (string, "EXECUTE.\n"); } else { GtkEntry *entry = GTK_ENTRY (get_widget_assert (scd->xml, "filter-variable-entry")); filter = gtk_entry_get_text (entry); } g_string_append_printf (string, "FILTER BY %s.\n", filter); text = string->str; g_string_free (string, FALSE); return text; }