/* 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);
}
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);
}
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;
}
static void
run_define_groups (PsppireDialogActionIndepSamps *act)
{
gint response;
PsppireDialogAction *da = PSPPIRE_DIALOG_ACTION (act);
if ( act->dg_table2->parent)
gtk_container_remove (GTK_CONTAINER (act->dg_table2->parent), act->dg_table2);
if ( act->dg_table1->parent)
gtk_container_remove (GTK_CONTAINER (act->dg_table1->parent), act->dg_table1);
if ( var_is_numeric (act->grp_var))
{
gtk_table_attach_defaults (GTK_TABLE (act->dg_table1), act->dg_table2,
1, 2, 1, 2);
gtk_container_add (GTK_CONTAINER (act->dg_box), act->dg_table1);
}
else
{
gtk_container_add (GTK_CONTAINER (act->dg_box), act->dg_table2);
act->group_defn = GROUPS_VALUES;
}
psppire_dialog_set_valid_predicate (PSPPIRE_DIALOG (act->dg_dialog),
define_groups_state_valid, act);
psppire_value_entry_set_variable (PSPPIRE_VALUE_ENTRY (act->dg_grp_entry[0]), act->grp_var);
psppire_value_entry_set_variable (PSPPIRE_VALUE_ENTRY (act->dg_grp_entry[1]), act->grp_var);
psppire_value_entry_set_variable (PSPPIRE_VALUE_ENTRY (act->dg_cut_point_entry), act->grp_var);
if ( act->group_defn != GROUPS_CUT_POINT )
{
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON (act->dg_cut_point_toggle_button), TRUE);
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON (act->dg_values_toggle_button), TRUE);
}
else
{
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON (act->dg_values_toggle_button), TRUE);
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON (act->dg_cut_point_toggle_button), TRUE);
}
g_signal_emit_by_name (act->dg_grp_entry[0], "changed");
g_signal_emit_by_name (act->dg_grp_entry[1], "changed");
g_signal_emit_by_name (act->dg_cut_point_entry, "changed");
response = psppire_dialog_run (PSPPIRE_DIALOG (act->def_grps_dialog));
if (response == PSPPIRE_RESPONSE_CONTINUE)
{
const int width = var_get_width (act->grp_var);
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (act->dg_values_toggle_button)))
{
act->group_defn = GROUPS_VALUES;
psppire_value_entry_get_value (PSPPIRE_VALUE_ENTRY (act->dg_grp_entry[0]),
&act->grp_val[0], width);
psppire_value_entry_get_value (PSPPIRE_VALUE_ENTRY (act->dg_grp_entry[1]),
&act->grp_val[1], width);
}
else
{
act->group_defn = GROUPS_CUT_POINT;
psppire_value_entry_get_value (PSPPIRE_VALUE_ENTRY (act->dg_cut_point_entry),
&act->cut_point, width);
}
psppire_dialog_notify_change (PSPPIRE_DIALOG (da->dialog));
}
}
/* Pops up the Compute dialog box */
void
compute_dialog (PsppireDataWindow *de)
{
gint response;
PsppireVarStore *vs = NULL;
struct compute_dialog scd;
GtkBuilder *xml = builder_new ("compute.ui");
GtkWidget *dialog = get_widget_assert (xml, "compute-variable-dialog");
GtkWidget *dict_view = get_widget_assert (xml, "compute-treeview1");
GtkWidget *functions = get_widget_assert (xml, "compute-treeview2");
GtkWidget *keypad = get_widget_assert (xml, "psppire-keypad1");
GtkWidget *target = get_widget_assert (xml, "compute-entry1");
GtkWidget *var_selector = get_widget_assert (xml, "compute-selector1");
GtkWidget *func_selector = get_widget_assert (xml, "compute-selector2");
GtkWidget *type_and_label = get_widget_assert (xml, "compute-button1");
GtkWidget *expression =
get_widget_assert (xml, "radio-button-expression-label");
g_object_get (de->data_editor, "var-store", &vs, NULL);
g_object_get (vs, "dictionary", &scd.dict, NULL);
scd.use_type = FALSE;
g_signal_connect (expression, "toggled",
G_CALLBACK(on_expression_toggle), &scd);
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (de));
g_object_set (dict_view, "model", scd.dict,
"selection-mode", GTK_SELECTION_SINGLE,
NULL);
psppire_selector_set_select_func (PSPPIRE_SELECTOR (var_selector),
insert_source_row_into_text_view, NULL);
function_list_populate (GTK_TREE_VIEW (functions));
psppire_selector_set_select_func (PSPPIRE_SELECTOR (func_selector),
insert_function_into_syntax_area, NULL);
scd.xml = xml;
psppire_dialog_set_valid_predicate (PSPPIRE_DIALOG (dialog),
contents_plausible, &scd);
g_signal_connect (target, "changed", G_CALLBACK (on_target_change), &scd);
g_signal_connect (dialog, "refresh", G_CALLBACK (refresh), &scd);
g_signal_connect (keypad, "insert-syntax",
G_CALLBACK (on_keypad_button), xml);
g_signal_connect (keypad, "erase",
G_CALLBACK (erase), xml);
g_signal_connect (type_and_label, "clicked",
G_CALLBACK (run_type_label_dialog), &scd);
response = psppire_dialog_run (PSPPIRE_DIALOG (dialog));
switch (response)
{
case GTK_RESPONSE_OK:
g_free (execute_syntax_string (de, generate_syntax (&scd)));
break;
case PSPPIRE_RESPONSE_PASTE:
g_free (paste_syntax_to_window (generate_syntax (&scd)));
break;
default:
break;
}
g_object_unref (xml);
}
/* Pops up the dialog box */
void
t_test_independent_samples_dialog (PsppireDataWindow *de)
{
struct tt_indep_samples_dialog tt_d;
gint response;
PsppireVarStore *vs = NULL;
GtkBuilder *xml = builder_new ("t-test.ui");
GtkWidget *dict_view =
get_widget_assert (xml, "indep-samples-t-test-treeview1");
GtkWidget *selector2 =
get_widget_assert (xml, "indep-samples-t-test-selector2");
GtkWidget *selector1 =
get_widget_assert (xml, "indep-samples-t-test-selector1");
GtkWidget *options_button =
get_widget_assert (xml, "indep-samples-t-test-options-button");
g_object_get (de->data_editor, "var-store", &vs, NULL);
tt_d.dialog = get_widget_assert (xml, "t-test-independent-samples-dialog");
tt_d.xml = xml;
g_object_get (vs, "dictionary", &tt_d.dict, NULL);
tt_d.define_groups_button = get_widget_assert (xml, "define-groups-button");
tt_d.groups_entry = get_widget_assert (xml, "indep-samples-t-test-entry");
tt_d.opts = tt_options_dialog_create (GTK_WINDOW (de));
tt_d.grps = tt_groups_dialog_create (xml, GTK_WINDOW (de));
gtk_window_set_transient_for (GTK_WINDOW (tt_d.dialog), GTK_WINDOW (de));
g_object_set (dict_view, "model", tt_d.dict, NULL);
psppire_selector_set_allow (PSPPIRE_SELECTOR (selector1),
numeric_only);
psppire_selector_set_filter_func (PSPPIRE_SELECTOR (selector2),
is_currently_in_entry);
g_signal_connect_swapped (tt_d.define_groups_button, "clicked",
G_CALLBACK (run_define_groups), &tt_d);
g_signal_connect_swapped (options_button, "clicked",
G_CALLBACK (tt_options_dialog_run), tt_d.opts);
g_signal_connect_swapped (tt_d.dialog, "refresh", G_CALLBACK (refresh),
&tt_d);
g_signal_connect (tt_d.groups_entry, "changed",
G_CALLBACK (set_define_groups_sensitivity), &tt_d);
psppire_dialog_set_valid_predicate (PSPPIRE_DIALOG (tt_d.dialog),
dialog_state_valid, &tt_d);
response = psppire_dialog_run (PSPPIRE_DIALOG (tt_d.dialog));
switch (response)
{
case GTK_RESPONSE_OK:
g_free (execute_syntax_string (de, generate_syntax (&tt_d)));
break;
case PSPPIRE_RESPONSE_PASTE:
g_free (paste_syntax_to_window (generate_syntax (&tt_d)));
break;
default:
break;
}
tt_options_dialog_destroy (tt_d.opts);
tt_groups_dialog_destroy (tt_d.grps);
g_object_unref (xml);
}
static void
run_define_groups (struct tt_indep_samples_dialog *ttd)
{
struct tt_groups_dialog *grps = ttd->grps;
gint response;
GtkWidget *box = get_widget_assert (ttd->xml, "dialog-hbox2");
const gchar *text = gtk_entry_get_text (GTK_ENTRY (ttd->groups_entry));
const struct variable *v = psppire_dict_lookup_var (ttd->dict, text);
if ( grps->table2->parent)
gtk_container_remove (GTK_CONTAINER (grps->table2->parent), grps->table2);
if ( grps->table1->parent)
gtk_container_remove (GTK_CONTAINER (grps->table1->parent), grps->table1);
if ( var_is_numeric (v))
{
gtk_table_attach_defaults (GTK_TABLE (grps->table1), grps->table2,
1, 2, 1, 2);
gtk_container_add (GTK_CONTAINER (box), grps->table1);
}
else
{
gtk_container_add (GTK_CONTAINER (box), grps->table2);
grps->group_defn = GROUPS_VALUES;
}
psppire_dialog_set_valid_predicate (PSPPIRE_DIALOG (grps->dialog),
define_groups_state_valid, grps);
if ( grps->group_defn != GROUPS_CUT_POINT )
{
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON (grps->cut_point_toggle_button), TRUE);
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON (grps->values_toggle_button), TRUE);
gtk_entry_set_text (GTK_ENTRY (grps->grp_entry[0]), grps->val[0]);
gtk_entry_set_text (GTK_ENTRY (grps->grp_entry[1]), grps->val[1]);
gtk_entry_set_text (GTK_ENTRY (grps->cut_point_entry), "");
}
else
{
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON (grps->values_toggle_button), TRUE);
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON (grps->cut_point_toggle_button), TRUE);
gtk_entry_set_text (GTK_ENTRY (grps->grp_entry[0]), "");
gtk_entry_set_text (GTK_ENTRY (grps->grp_entry[1]), "");
gtk_entry_set_text (GTK_ENTRY (grps->cut_point_entry), grps->val[0]);
}
g_signal_emit_by_name (grps->grp_entry[0], "changed");
g_signal_emit_by_name (grps->grp_entry[1], "changed");
g_signal_emit_by_name (grps->cut_point_entry, "changed");
response = psppire_dialog_run (PSPPIRE_DIALOG (grps->dialog));
if (response == PSPPIRE_RESPONSE_CONTINUE)
{
g_free (grps->val[0]);
g_free (grps->val[1]);
if (gtk_toggle_button_get_active
(GTK_TOGGLE_BUTTON (grps->values_toggle_button)))
{
grps->group_defn = GROUPS_VALUES;
grps->val[0] =
xstrdup (gtk_entry_get_text (GTK_ENTRY (grps->grp_entry[0])));
grps->val[1] =
xstrdup (gtk_entry_get_text (GTK_ENTRY (grps->grp_entry[1])));
}
else
{
grps->group_defn = GROUPS_CUT_POINT;
grps->val[1] = NULL;
grps->val[0] =
xstrdup (gtk_entry_get_text (GTK_ENTRY (grps->cut_point_entry)));
}
psppire_dialog_notify_change (PSPPIRE_DIALOG (ttd->dialog));
}
}
static void
recode_dialog (PsppireDataWindow *de, gboolean diff)
{
gint response;
struct recode_dialog rd;
GtkBuilder *builder = builder_new ("recode.ui");
GtkWidget *selector = get_widget_assert (builder, "psppire-selector1");
GtkWidget *oldandnew = get_widget_assert (builder, "button1");
GtkWidget *output_variable_box = get_widget_assert (builder,"frame4");
PsppireVarStore *vs = NULL;
g_object_get (de->data_editor, "var-store", &vs, NULL);
rd.change_button = get_widget_assert (builder, "change-button");
rd.varmap = NULL;
rd.dialog = get_widget_assert (builder, "recode-dialog");
rd.dict_treeview = get_widget_assert (builder, "treeview1");
rd.variable_treeview = get_widget_assert (builder, "treeview2");
rd.new_name_entry = get_widget_assert (builder, "dest-name-entry");
rd.new_label_entry = get_widget_assert (builder, "dest-label-entry");
g_object_get (vs, "dictionary", &rd.dict, NULL);
rd.value_map = gtk_list_store_new (2,
old_value_get_type (),
new_value_get_type ()
);
g_object_set (output_variable_box, "visible", diff, NULL);
if ( diff )
gtk_window_set_title (GTK_WINDOW (rd.dialog),
_("Recode into Different Variables"));
else
gtk_window_set_title (GTK_WINDOW (rd.dialog),
_("Recode into Same Variables"));
rd.different = diff;
gtk_window_set_transient_for (GTK_WINDOW (rd.dialog), GTK_WINDOW (de));
g_object_set (rd.dict_treeview, "model", rd.dict, NULL);
if (rd.different)
{
GtkTreeSelection *sel;
GtkCellRenderer *renderer = gtk_cell_renderer_text_new ();
GtkTreeViewColumn *col = gtk_tree_view_column_new_with_attributes (_("New"),
renderer,
"text", NULL,
NULL);
gtk_tree_view_column_set_cell_data_func (col, renderer,
render_new_var_name,
&rd, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (rd.variable_treeview), col);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (rd.variable_treeview), 0);
g_object_set (col, "title", _("Old"), NULL);
g_object_set (rd.variable_treeview, "headers-visible", TRUE, NULL);
rd.varmap = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, nlp_destroy);
sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (rd.variable_treeview));
g_signal_connect (sel, "changed",
G_CALLBACK (on_selection_change), &rd);
g_signal_connect (rd.change_button, "clicked",
G_CALLBACK (on_change_clicked), &rd);
}
psppire_selector_set_allow (PSPPIRE_SELECTOR (selector), homogeneous_types);
/* Set up the Old & New Values subdialog */
{
rd.string_button = get_widget_assert (builder, "checkbutton1");
rd.width_entry = get_widget_assert (builder, "spinbutton1");
rd.convert_button = get_widget_assert (builder, "checkbutton2");
rd.old_value_chooser = get_widget_assert (builder, "val-chooser");
rd.new_value_entry = get_widget_assert (builder, "entry1");
rd.toggle[BUTTON_NEW_VALUE] = get_widget_assert (builder, "radiobutton1");
rd.toggle[BUTTON_NEW_SYSMIS] = get_widget_assert (builder, "radiobutton2");
rd.toggle[BUTTON_NEW_COPY] = get_widget_assert (builder, "radiobutton3");
rd.new_copy_label = get_widget_assert (builder, "label3");
rd.strings_box = get_widget_assert (builder, "table3");
rd.old_and_new_dialog =
PSPPIRE_DIALOG (get_widget_assert (builder, "old-new-values-dialog"));
gtk_window_set_transient_for (GTK_WINDOW (rd.old_and_new_dialog),
GTK_WINDOW (de));
rd.acr = PSPPIRE_ACR (get_widget_assert (builder, "psppire-acr1"));
g_signal_connect_swapped (rd.toggle[BUTTON_NEW_VALUE], "toggled",
G_CALLBACK (set_acr), &rd);
g_signal_connect_swapped (rd.new_value_entry, "changed",
G_CALLBACK (set_acr), &rd);
{
GtkTreeSelection *sel;
/* Remove the ACR's default column. We don't like it */
GtkTreeViewColumn *column = gtk_tree_view_get_column (rd.acr->tv, 0);
gtk_tree_view_remove_column (rd.acr->tv, column);
column =
gtk_tree_view_column_new_with_attributes (_("Old"),
gtk_cell_renderer_text_new (),
"text", 0,
NULL);
gtk_tree_view_append_column (rd.acr->tv, column);
column =
gtk_tree_view_column_new_with_attributes (_("New"),
gtk_cell_renderer_text_new (),
"text", 1,
NULL);
gtk_tree_view_append_column (rd.acr->tv, column);
g_object_set (rd.acr->tv, "headers-visible", TRUE, NULL);
sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (rd.acr->tv));
g_signal_connect (sel, "changed",
G_CALLBACK (on_acr_selection_change), &rd);
}
g_signal_connect_swapped (oldandnew, "clicked",
G_CALLBACK (run_old_and_new_dialog), &rd);
g_signal_connect (rd.toggle[BUTTON_NEW_VALUE], "toggled",
G_CALLBACK (toggle_sensitivity), rd.new_value_entry);
g_signal_connect (rd.string_button, "toggled",
G_CALLBACK (toggle_sensitivity), rd.width_entry);
g_signal_connect (rd.string_button, "toggled",
G_CALLBACK (on_string_toggled), &rd);
g_signal_connect (rd.convert_button, "toggled",
G_CALLBACK (on_convert_toggled), &rd);
g_signal_connect_swapped (rd.old_and_new_dialog, "show",
G_CALLBACK (on_old_new_show), &rd);
}
g_signal_connect (rd.dialog, "refresh", G_CALLBACK (refresh), &rd);
psppire_dialog_set_valid_predicate (PSPPIRE_DIALOG (rd.dialog),
dialog_state_valid, &rd);
response = psppire_dialog_run (PSPPIRE_DIALOG (rd.dialog));
switch (response)
{
case GTK_RESPONSE_OK:
g_free (execute_syntax_string (de, generate_syntax (&rd)));
break;
case PSPPIRE_RESPONSE_PASTE:
g_free (paste_syntax_to_window (generate_syntax (&rd)));
break;
default:
break;
}
if (rd.varmap)
g_hash_table_destroy (rd.varmap);
gtk_list_store_clear (GTK_LIST_STORE (rd.value_map));
g_object_unref (rd.value_map);
g_object_unref (builder);
}
/* Pops up the Crosstabs dialog box */
void
crosstabs_dialog (PsppireDataWindow *de)
{
gint response;
struct crosstabs_dialog cd;
GtkBuilder *xml = builder_new ("crosstabs.ui");
PsppireVarStore *vs = NULL;
PsppireDict *dict = NULL;
GtkWidget *dialog = get_widget_assert (xml, "crosstabs-dialog");
GtkWidget *source = get_widget_assert (xml, "dict-treeview");
GtkWidget *dest_rows = get_widget_assert (xml, "rows");
GtkWidget *dest_cols = get_widget_assert (xml, "cols");
GtkWidget *format_button = get_widget_assert (xml, "format-button");
GtkWidget *stat_button = get_widget_assert (xml, "stats-button");
GtkWidget *cell_button = get_widget_assert (xml, "cell-button");
cd.stat_view = get_widget_assert (xml, "stats-view");
cd.cell_view = get_widget_assert (xml, "cell-view");
g_object_get (de->data_editor, "var-store", &vs, NULL);
put_checkbox_items_in_treeview (GTK_TREE_VIEW(cd.stat_view),
B_CS_STATS_DEFAULT,
N_CROSSTABS_STATS,
stats
);
put_checkbox_items_in_treeview (GTK_TREE_VIEW(cd.cell_view),
B_CS_CELL_DEFAULT,
N_CROSSTABS_CELLS,
cells
);
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (de));
g_object_get (vs, "dictionary", &dict, NULL);
g_object_set (source, "model", dict, NULL);
cd.row_vars = GTK_TREE_VIEW (dest_rows);
cd.col_vars = GTK_TREE_VIEW (dest_cols);
g_object_get (vs, "dictionary", &cd.dict, NULL);
cd.format_dialog = get_widget_assert (xml, "format-dialog");
cd.table_button = GTK_TOGGLE_BUTTON (get_widget_assert (xml, "print-tables"));
cd.pivot_button = GTK_TOGGLE_BUTTON (get_widget_assert (xml, "pivot"));
cd.stat_dialog = get_widget_assert (xml, "stat-dialog");
cd.cell_dialog = get_widget_assert (xml, "cell-dialog");
cd.stat = gtk_tree_view_get_model (GTK_TREE_VIEW (cd.stat_view));
cd.cell = gtk_tree_view_get_model (GTK_TREE_VIEW (cd.cell_view));
cd.avalue = GTK_TOGGLE_BUTTON (get_widget_assert (xml, "ascending"));
cd.current_opts.avalue = TRUE;
cd.current_opts.table = TRUE;
cd.current_opts.pivot = TRUE;
gtk_window_set_transient_for (GTK_WINDOW (cd.format_dialog), GTK_WINDOW (de));
gtk_window_set_transient_for (GTK_WINDOW (cd.cell_dialog), GTK_WINDOW (de));
gtk_window_set_transient_for (GTK_WINDOW (cd.stat_dialog), GTK_WINDOW (de));
g_signal_connect (dialog, "refresh", G_CALLBACK (refresh), &cd);
psppire_dialog_set_valid_predicate (PSPPIRE_DIALOG (dialog),
dialog_state_valid, &cd);
g_signal_connect_swapped (format_button, "clicked",
G_CALLBACK (on_format_clicked), &cd);
g_signal_connect_swapped (stat_button, "clicked",
G_CALLBACK (on_statistics_clicked), &cd);
g_signal_connect_swapped (cell_button, "clicked",
G_CALLBACK (on_cell_clicked), &cd);
response = psppire_dialog_run (PSPPIRE_DIALOG (dialog));
switch (response)
{
case GTK_RESPONSE_OK:
g_free (execute_syntax_string (de, generate_syntax (&cd)));
break;
case PSPPIRE_RESPONSE_PASTE:
g_free (paste_syntax_to_window (generate_syntax (&cd)));
break;
default:
break;
}
g_object_unref (xml);
}
