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