static void do_about()
{
GtkBuilder *builder = NULL;
static GtkWidget *widget;
if (widget == NULL)
{
builder = builder_new(UI_DIR"/about.ui");
if (builder == NULL)
{
g_warning("Missing about.ui file!\n");
return ;
}
widget = builder_get_widget(builder, "dialog_about");
if (widget == NULL){
g_warning("Missing about dialog!\n");
}
else
{
gtk_window_set_transient_for(GTK_WINDOW(widget), GTK_WINDOW(main_window));
gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(widget), VERSION);
}
g_object_unref(builder);
}
if (widget == NULL)
return ;
gtk_dialog_run(GTK_DIALOG(widget));
gtk_widget_hide(widget);
}
static void
psppire_dialog_action_indep_samps_activate (GtkAction *a)
{
PsppireDialogActionIndepSamps *act = PSPPIRE_DIALOG_ACTION_INDEP_SAMPS (a);
PsppireDialogAction *pda = PSPPIRE_DIALOG_ACTION (a);
GtkBuilder *xml = builder_new ("indep-samples.ui");
pda->dialog = get_widget_assert (xml,"independent-samples-dialog");
pda->source = get_widget_assert (xml, "indep-samples-treeview1");
act->define_groups_button = get_widget_assert (xml, "define-groups-button");
act->options_button = get_widget_assert (xml, "indep-samples-options-button");
act->def_grps_dialog = get_widget_assert (xml, "define-groups-dialog");
act->group_var_entry = get_widget_assert (xml, "indep-samples-entry");
act->test_vars_tv = get_widget_assert (xml, "indep-samples-treeview2");
act->dg_dialog = get_widget_assert (xml, "define-groups-dialog");
act->dg_grp_entry[0] = get_widget_assert (xml, "group1-entry");
act->dg_grp_entry[1] = get_widget_assert (xml, "group2-entry");
act->dg_cut_point_entry = get_widget_assert (xml, "cut-point-entry");
act->dg_box = get_widget_assert (xml, "dialog-hbox2");
act->dg_table1 = get_widget_assert (xml, "table1");
act->dg_table2 = get_widget_assert (xml, "table2");
act->dg_label = get_widget_assert (xml, "label4");
act->dg_hbox1 = get_widget_assert (xml, "hbox1");
act->dg_values_toggle_button = get_widget_assert (xml, "radiobutton3");
act->dg_cut_point_toggle_button = get_widget_assert (xml, "radiobutton4");
act->opts = tt_options_dialog_create (GTK_WINDOW (pda->toplevel));
g_object_ref (act->dg_table1);
g_object_ref (act->dg_table2);
g_signal_connect (act->dg_values_toggle_button, "toggled",
G_CALLBACK (set_group_criterion_type), act);
g_object_unref (xml);
psppire_dialog_action_set_refresh (pda, refresh);
psppire_dialog_action_set_valid_predicate (pda,
dialog_state_valid);
g_signal_connect_swapped (act->define_groups_button, "clicked",
G_CALLBACK (run_define_groups), act);
g_signal_connect_swapped (act->options_button, "clicked",
G_CALLBACK (tt_options_dialog_run), act->opts);
g_signal_connect (act->group_var_entry, "changed",
G_CALLBACK (on_grp_var_change), act);
if (PSPPIRE_DIALOG_ACTION_CLASS (psppire_dialog_action_indep_samps_parent_class)->activate)
PSPPIRE_DIALOG_ACTION_CLASS (psppire_dialog_action_indep_samps_parent_class)->activate (pda);
}
/* 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);
}
/* Creates the dialog structure */
struct missing_val_dialog *
missing_val_dialog_create (GtkWindow *toplevel)
{
GtkBuilder *xml = builder_new ("var-sheet-dialogs.ui");
struct missing_val_dialog *dialog = g_malloc (sizeof (*dialog));
dialog->window = get_widget_assert (xml, "missing_values_dialog");
gtk_window_set_transient_for
(GTK_WINDOW (dialog->window), toplevel);
g_signal_connect_swapped (get_widget_assert (xml, "missing_val_cancel"),
"clicked", G_CALLBACK (gtk_widget_hide), dialog->window);
g_signal_connect (get_widget_assert (xml, "missing_val_ok"),
"clicked", G_CALLBACK (missing_val_dialog_accept), dialog);
g_signal_connect (dialog->window, "delete-event",
G_CALLBACK (on_delete), dialog);
dialog->mv[0] = get_widget_assert (xml, "mv0");
dialog->mv[1] = get_widget_assert (xml, "mv1");
dialog->mv[2] = get_widget_assert (xml, "mv2");
dialog->low = get_widget_assert (xml, "mv-low");
dialog->high = get_widget_assert (xml, "mv-high");
dialog->discrete = get_widget_assert (xml, "mv-discrete");
dialog->button_none =
GTK_TOGGLE_BUTTON (get_widget_assert (xml, "no_missing"));
dialog->button_discrete =
GTK_TOGGLE_BUTTON (get_widget_assert (xml, "discrete_missing"));
dialog->button_range =
GTK_TOGGLE_BUTTON (get_widget_assert (xml, "range_missing"));
g_signal_connect (dialog->button_discrete, "toggled",
G_CALLBACK (discrete), dialog);
g_signal_connect (dialog->button_range, "toggled",
G_CALLBACK (range), dialog);
g_object_unref (xml);
return dialog;
}
static void
psppire_dialog_action_examine_activate (GtkAction *a)
{
PsppireDialogAction *pda = PSPPIRE_DIALOG_ACTION (a);
PsppireDialogActionExamine *act = PSPPIRE_DIALOG_ACTION_EXAMINE (a);
GtkBuilder *xml = builder_new ("examine.ui");
GtkWidget *stats_button = get_widget_assert (xml, "stats-button");
GtkWidget *opts_button = get_widget_assert (xml, "opts-button");
GtkWidget *dep_sel = get_widget_assert (xml, "psppire-selector1");
pda->dialog = get_widget_assert (xml, "examine-dialog");
pda->source = get_widget_assert (xml, "treeview1");
act->variables = get_widget_assert (xml, "treeview2");
act->factors = get_widget_assert (xml, "treeview3");
act->id_var = get_widget_assert (xml, "entry1");
act->stats_dialog = get_widget_assert (xml, "statistics-dialog");
act->descriptives_button = get_widget_assert (xml, "descriptives-button");
act->extremes_button = get_widget_assert (xml, "extremes-button");
act->percentiles_button = get_widget_assert (xml, "percentiles-button");
act->opts_dialog = get_widget_assert (xml, "options-dialog");
act->listwise = get_widget_assert (xml, "radiobutton1");
act->pairwise = get_widget_assert (xml, "radiobutton2");
act->report = get_widget_assert (xml, "radiobutton3");
g_object_set (pda->source,
"model", pda->dict,
NULL);
psppire_selector_set_allow (PSPPIRE_SELECTOR (dep_sel), numeric_only);
psppire_dialog_action_set_valid_predicate (pda, (void *) dialog_state_valid);
psppire_dialog_action_set_refresh (pda, dialog_refresh);
g_signal_connect_swapped (stats_button, "clicked",
G_CALLBACK (run_stats_dialog), act);
g_signal_connect_swapped (opts_button, "clicked",
G_CALLBACK (run_opts_dialog), act);
PSPPIRE_DIALOG_ACTION_CLASS (psppire_dialog_action_examine_parent_class)->activate (pda);
}
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
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);
}
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);
}
/* Pops up the Select Cases dialog box */
void
select_cases_dialog (PsppireDataWindow *de)
{
gint response;
struct select_cases_dialog scd = {0,0,0,0,0,0};
GtkWidget *dialog ;
GtkWidget *entry = NULL;
GtkWidget *selector ;
GtkWidget *button_range;
GtkWidget *button_sample;
scd.xml = builder_new ("select-cases.ui");
g_object_get (de->data_editor, "data-store", &scd.data_store, NULL);
button_range = get_widget_assert (scd.xml, "button-range");
button_sample = get_widget_assert (scd.xml, "button-sample");
entry = get_widget_assert (scd.xml, "filter-variable-entry");
selector = get_widget_assert (scd.xml, "psppire-selector-filter");
{
GtkWidget *button_if =
get_widget_assert (scd.xml, "button-if");
GtkWidget *radiobutton_if =
get_widget_assert (scd.xml, "radiobutton-if");
GtkWidget *radiobutton_all =
get_widget_assert (scd.xml, "radiobutton-all");
GtkWidget *radiobutton_sample =
get_widget_assert (scd.xml, "radiobutton-sample");
GtkWidget *radiobutton_range =
get_widget_assert (scd.xml, "radiobutton-range");
GtkWidget *radiobutton_filter =
get_widget_assert (scd.xml, "radiobutton-filter-variable");
GtkWidget *range_label =
get_widget_assert (scd.xml, "range-sample-label");
GtkWidget *sample_label =
get_widget_assert (scd.xml, "random-sample-label");
g_signal_connect (radiobutton_all, "toggled",
G_CALLBACK (set_sensitivity_from_toggle_invert),
get_widget_assert (scd.xml, "filter-delete-button-box")
);
g_signal_connect (button_if, "clicked",
G_CALLBACK (set_radiobutton), radiobutton_if);
g_signal_connect (button_sample, "clicked",
G_CALLBACK (set_radiobutton), radiobutton_sample);
g_signal_connect (button_range, "clicked",
G_CALLBACK (set_radiobutton), radiobutton_range);
g_signal_connect (selector, "clicked",
G_CALLBACK (set_radiobutton), radiobutton_filter);
g_signal_connect (selector, "selected",
G_CALLBACK (set_radiobutton), radiobutton_filter);
g_signal_connect (radiobutton_range, "toggled",
G_CALLBACK (set_sensitivity_from_toggle),
range_label
);
g_signal_connect (radiobutton_sample, "toggled",
G_CALLBACK (set_sensitivity_from_toggle),
sample_label
);
g_signal_connect (radiobutton_filter, "toggled",
G_CALLBACK (set_sensitivity_from_toggle),
entry
);
}
dialog = get_widget_assert (scd.xml, "select-cases-dialog");
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (de));
{
GtkWidget *source = get_widget_assert (scd.xml, "select-cases-treeview");
g_object_set (source, "model",
scd.data_store->dict,
"selection-mode",
GTK_SELECTION_SINGLE, NULL);
psppire_selector_set_filter_func (PSPPIRE_SELECTOR (selector),
is_currently_in_entry);
}
g_signal_connect (button_range,
"clicked", G_CALLBACK (range_subdialog), &scd);
g_signal_connect (button_sample,
"clicked", G_CALLBACK (sample_subdialog), &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 (scd.xml);
}
/* 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
psppire_dialog_action_crosstabs_activate (GtkAction *a)
{
PsppireDialogActionCrosstabs *act = PSPPIRE_DIALOG_ACTION_CROSSTABS (a);
PsppireDialogAction *pda = PSPPIRE_DIALOG_ACTION (a);
GtkBuilder *xml = builder_new ("crosstabs.ui");
pda->dialog = get_widget_assert (xml, "crosstabs-dialog");
pda->source = get_widget_assert (xml, "dict-treeview");
act->dest_rows = get_widget_assert (xml, "rows");
act->dest_cols = get_widget_assert (xml, "cols");
act->format_button = get_widget_assert (xml, "format-button");
act->stat_button = get_widget_assert (xml, "stats-button");
act->cell_button = get_widget_assert (xml, "cell-button");
act->stat_view = get_widget_assert (xml, "stats-view");
act->cell_view = get_widget_assert (xml, "cell-view");
act->cell_dialog = get_widget_assert (xml, "cell-dialog");
act->stat_dialog = get_widget_assert (xml, "stat-dialog");
act->format_dialog = get_widget_assert (xml, "format-dialog");
act->avalue_button = get_widget_assert (xml, "ascending");
act->table_button = get_widget_assert (xml, "print-tables");
act->pivot_button = get_widget_assert (xml, "pivot");
g_object_unref (xml);
act->format_options_avalue = TRUE;
act->format_options_table = TRUE;
act->format_options_pivot = TRUE;
psppire_checkbox_treeview_populate (PSPPIRE_CHECKBOX_TREEVIEW (act->cell_view),
B_CS_CELL_DEFAULT,
N_CROSSTABS_CELLS,
cells);
act->cell = gtk_tree_view_get_model (GTK_TREE_VIEW (act->cell_view));
psppire_checkbox_treeview_populate (PSPPIRE_CHECKBOX_TREEVIEW (act->stat_view),
B_CS_STATS_DEFAULT,
N_CROSSTABS_STATS,
stats);
act->stat = gtk_tree_view_get_model (GTK_TREE_VIEW (act->stat_view));
psppire_dialog_action_set_refresh (pda, refresh);
psppire_dialog_action_set_valid_predicate (pda,
dialog_state_valid);
g_signal_connect_swapped (act->cell_button, "clicked",
G_CALLBACK (on_cell_clicked), act);
g_signal_connect_swapped (act->stat_button, "clicked",
G_CALLBACK (on_statistics_clicked), act);
g_signal_connect_swapped (act->format_button, "clicked",
G_CALLBACK (on_format_clicked), act);
if (PSPPIRE_DIALOG_ACTION_CLASS (psppire_dialog_action_crosstabs_parent_class)->activate)
PSPPIRE_DIALOG_ACTION_CLASS (psppire_dialog_action_crosstabs_parent_class)->activate (pda);
}
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);
}
void
comments_dialog (PsppireDataWindow *de)
{
GtkTextIter iter;
gint response ;
struct comment_dialog cd;
GtkBuilder *xml = builder_new ("psppire.ui");
GtkWidget *dialog = get_widget_assert (xml, "comments-dialog");
GtkWidget *textview = get_widget_assert (xml, "comments-textview1");
GtkWidget *label = get_widget_assert (xml, "column-number-label");
GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (textview));
PsppireVarStore *vs = NULL;
g_object_get (de->data_editor, "var-store", &vs, NULL);
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (de));
{
PangoContext * context ;
PangoLayout * layout ;
PangoRectangle rect;
/* Since we're going to truncate lines to 80 chars,
we need a monospaced font otherwise it'll look silly */
PangoFontDescription *font_desc =
pango_font_description_from_string ("monospace");
gtk_widget_modify_font (textview, font_desc);
/* and let's just make sure that a complete line fits into the
widget's width */
context = gtk_widget_create_pango_context (textview);
layout = pango_layout_new (context);
pango_layout_set_text (layout, "M", 1);
pango_layout_set_font_description (layout, font_desc);
pango_layout_get_extents (layout, NULL, &rect);
g_object_set (textview, "width-request",
PANGO_PIXELS (rect.width) * DOC_LINE_LENGTH + 20, NULL);
g_object_unref (G_OBJECT (layout));
g_object_unref (G_OBJECT (context));
pango_font_description_free (font_desc);
}
cd.xml = xml;
g_object_get (vs, "dictionary", &cd.dict, NULL);
g_signal_connect (buffer, "mark-set",
G_CALLBACK (set_column_number), label);
g_signal_connect_after (buffer, "insert-text",
G_CALLBACK (wrap_line), NULL);
gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);
gtk_text_buffer_place_cursor (buffer, &iter);
g_signal_connect (dialog, "refresh", G_CALLBACK (refresh), &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);
}
