/**
* kaplan_meier_tool_ok_clicked_cb:
* @button:
* @state:
*
* Retrieve the information from the dialog and call the kaplan_meier_tool.
* Note that we assume that the ok_button is only active if the entry fields
* contain sensible data.
**/
static void
kaplan_meier_tool_ok_clicked_cb (G_GNUC_UNUSED GtkWidget *button,
KaplanMeierToolState *state)
{
data_analysis_output_t *dao;
analysis_tools_data_kaplan_meier_t *data;
data = g_new0 (analysis_tools_data_kaplan_meier_t, 1);
dao = parse_output ((GenericToolState *)state, NULL);
data->base.wbc = WORKBOOK_CONTROL (state->base.wbcg);
if (state->base.warning_dialog != NULL)
gtk_widget_destroy (state->base.warning_dialog);
data->base.range_1 = gnm_expr_entry_parse_as_value
(GNM_EXPR_ENTRY (state->base.input_entry), state->base.sheet);
data->censored = gtk_toggle_button_get_active (
GTK_TOGGLE_BUTTON (state->censorship_button));
if (data->censored)
data->base.range_2 = gnm_expr_entry_parse_as_value
(GNM_EXPR_ENTRY (state->base.input_entry_2), state->base.sheet);
else
data->base.range_2 = NULL;
data->censor_mark = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (state->censor_spin_from));
data->censor_mark_to = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (state->censor_spin_to));
data->group_list = kaplan_meier_tool_get_groups (state);
if (data->group_list == NULL) {
data->range_3 = NULL;
data->logrank_test = FALSE;
} else {
data->range_3 = gnm_expr_entry_parse_as_value
(GNM_EXPR_ENTRY (state->groups_input), state->base.sheet);
data->logrank_test = gtk_toggle_button_get_active (
GTK_TOGGLE_BUTTON (state->logrank_button));
}
data->median = gtk_toggle_button_get_active (
GTK_TOGGLE_BUTTON (glade_xml_get_widget
(state->base.gui,
"median-button")));
data->chart = gtk_toggle_button_get_active (
GTK_TOGGLE_BUTTON (state->graph_button));
data->ticks = gtk_toggle_button_get_active (
GTK_TOGGLE_BUTTON (state->tick_button));
data->std_err = gtk_toggle_button_get_active (
GTK_TOGGLE_BUTTON (state->std_error_button));
if (!cmd_analysis_tool (WORKBOOK_CONTROL (state->base.wbcg), state->base.sheet,
dao, data, analysis_tool_kaplan_meier_engine))
gtk_widget_destroy (state->base.dialog);
return;
}
/**
* random_cor_tool_ok_clicked_cb:
* @button:
* @state:
*
* Retrieve the information from the dialog and call the appropriate tool.
* Note that we assume that the ok_button is only active if the entry fields
* contain sensible data.
**/
static void
random_cor_tool_ok_clicked_cb (GtkWidget *button, RandomCorToolState *state)
{
data_analysis_output_t *dao;
tools_data_random_cor_t *data;
gint err;
data = g_new0 (tools_data_random_cor_t, 1);
dao = parse_output ((GnmGenericToolState *)state, NULL);
err = entry_to_int (GTK_ENTRY (state->count_entry), &data->count, FALSE);
data->matrix = gnm_expr_entry_parse_as_value
(GNM_EXPR_ENTRY (state->base.input_entry),
state->base.sheet);
data->variables = data->matrix->v_range.cell.b.row -
data->matrix->v_range.cell.a.row + 1;
data->matrix_type = gnm_gui_group_value
(state->base.gui, matrix_group);
if (!cmd_analysis_tool (GNM_WBC (state->base.wbcg),
state->base.sheet,
dao, data, tool_random_cor_engine, TRUE) &&
(button == state->base.ok_button))
gtk_widget_destroy (state->base.dialog);
}
static GnmExprEntry *
init_entry (GnmDialogDataTable *state, char const *name)
{
GtkWidget *w = glade_xml_get_widget (state->gui, name);
g_return_val_if_fail (w != NULL, NULL);
gnm_expr_entry_set_flags (GNM_EXPR_ENTRY (w),
GNM_EE_SINGLE_RANGE | GNM_EE_SHEET_OPTIONAL | GNM_EE_FORCE_REL_REF,
GNM_EE_MASK);
g_object_set (G_OBJECT (w),
"scg", wbcg_cur_scg (state->wbcg),
"with-icon", TRUE,
NULL);
return GNM_EXPR_ENTRY (w);
}
static void
scenarios_summary_clicked_cb (G_GNUC_UNUSED GtkWidget *button,
ScenariosState *state)
{
Sheet *new_sheet;
GSList *results;
restore_old_values (state);
results = gnm_expr_entry_parse_as_list (
GNM_EXPR_ENTRY (state->base.input_entry), state->base.sheet);
if (results == NULL) {
go_gtk_notice_dialog (GTK_WINDOW (state->base.dialog),
GTK_MESSAGE_ERROR,
_("Results entry did not contain valid "
"cell names."));
return;
}
scenario_summary (WORKBOOK_CONTROL (state->base.wbcg), state->base.sheet,
results, &new_sheet);
state->new_report_sheets =
g_slist_prepend (state->new_report_sheets,
new_sheet);
if (results)
g_slist_free_full (results, (GDestroyNotify)value_release);
}
static void
cb_focus_on_entry (GtkWidget *widget, GtkWidget *entry)
{
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
gtk_widget_grab_focus (GTK_WIDGET (gnm_expr_entry_get_entry
(GNM_EXPR_ENTRY (entry))));
}
/**
* shuffle_ok_clicked_cb:
* @button:
* @state:
*
* Retrieve the information from the dialog and call the data_shuffling.
* Note that we assume that the ok_button is only active if the entry fields
* contain sensible data.
**/
static void
shuffle_ok_clicked_cb (G_GNUC_UNUSED GtkWidget *button, ShuffleState *state)
{
data_analysis_output_t *dao;
data_shuffling_t *ds;
WorkbookControl *wbc;
GnmValue *input;
int type;
/* This is free'ed by data_shuffling_free. */
/* We later want to extend this to shuffle to other locations */
dao = dao_init (NULL, InPlaceOutput);
input = gnm_expr_entry_parse_as_value (
GNM_EXPR_ENTRY (state->input_entry), state->sheet);
if (dao->type == InPlaceOutput)
dao_load_from_value (dao, input);
type = gnm_gui_group_value (state->gui, shuffle_by);
ds = data_shuffling (WORKBOOK_CONTROL (state->wbcg), dao,
state->sheet, input, type);
wbc = WORKBOOK_CONTROL (state->wbcg);
cmd_data_shuffle (wbc, ds, state->sheet);
value_release (input);
gtk_widget_destroy (state->dialog);
}
static void
gnm_dao_setup_signals (GnmDao *gdao)
{
g_signal_connect (G_OBJECT (gdao->output_range),
"toggled",
G_CALLBACK (cb_focus_on_entry),
gdao->output_entry);
g_signal_connect
(G_OBJECT (gnm_expr_entry_get_entry
(GNM_EXPR_ENTRY (gdao->output_entry))),
"focus-in-event",
G_CALLBACK (tool_set_focus_output_range), gdao);
g_signal_connect_after (G_OBJECT (gdao->output_entry),
"changed",
G_CALLBACK (cb_set_sensitivity), gdao);
g_signal_connect_after (G_OBJECT (gdao->output_entry),
"changed",
G_CALLBACK (cb_emit_readiness_changed),
gdao);
g_signal_connect (G_OBJECT (gdao->output_entry),
"activate",
G_CALLBACK (cb_emit_activate), gdao);
g_signal_connect_after (G_OBJECT (gdao->output_range),
"toggled",
G_CALLBACK (cb_set_sensitivity), gdao);
g_signal_connect_after (G_OBJECT (gdao->output_range),
"toggled",
G_CALLBACK (cb_emit_readiness_changed),
gdao);
}
static void
cb_source_expr_changed (DialogDataSlicer *state)
{
GnmValue *range;
range = gnm_expr_entry_parse_as_value
(GNM_EXPR_ENTRY (state->source_expr), sv_sheet (state->sv));
#warning "FIXME: Now what?"
value_release (range);
}
static void
cb_guru_set_focus (G_GNUC_UNUSED GtkWidget *window,
GtkWidget *focus_widget, WBCGtk *wbcg)
{
GnmExprEntry *gee = NULL;
if (focus_widget != NULL &&
GNM_EXPR_ENTRY_IS (gtk_widget_get_parent (focus_widget)))
gee = GNM_EXPR_ENTRY (gtk_widget_get_parent (focus_widget));
wbcg_set_entry (wbcg, gee);
}
/**
* advanced_filter_ok_clicked_cb:
* @button:
* @state:
*
* Retrieve the information from the dialog and call the advanced_filter.
* Note that we assume that the ok_button is only active if the entry fields
* contain sensible data.
**/
static void
advanced_filter_ok_clicked_cb (G_GNUC_UNUSED GtkWidget *button,
AdvancedFilterState *state)
{
data_analysis_output_t dao;
GnmValue *input;
GnmValue *criteria;
char *text;
GtkWidget *w;
int err = 0;
gboolean unique;
input = gnm_expr_entry_parse_as_value (
GNM_EXPR_ENTRY (state->input_entry), state->sheet);
criteria = gnm_expr_entry_parse_as_value
(state->input_entry_2, state->sheet);
parse_output ((GenericToolState *) state, &dao);
w = glade_xml_get_widget (state->gui, "unique-button");
unique = (1 == gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)));
err = advanced_filter (WORKBOOK_CONTROL (state->wbcg),
&dao, input, criteria, unique);
value_release (input);
value_release (criteria);
switch (err) {
case OK:
gtk_widget_destroy (state->dialog);
break;
case ERR_INVALID_FIELD:
error_in_entry ((GenericToolState *) state,
GTK_WIDGET (state->input_entry_2),
_("The given criteria are invalid."));
break;
case NO_RECORDS_FOUND:
go_gtk_notice_nonmodal_dialog ((GtkWindow *) state->dialog,
&(state->warning_dialog),
GTK_MESSAGE_INFO,
_("No matching records were found."));
break;
default:
text = g_strdup_printf (_("An unexpected error has occurred: "
"%d."), err);
error_in_entry ((GenericToolState *) state,
GTK_WIDGET (state->input_entry), text);
g_free (text);
break;
}
return;
}
/**
* shuffle_update_sensitivity_cb:
* @dummy:
* @state:
*
* Update the dialog widgets sensitivity
**/
static void
shuffle_update_sensitivity_cb (G_GNUC_UNUSED GtkWidget *dummy,
ShuffleState *state)
{
GnmValue *input_range = gnm_expr_entry_parse_as_value (
GNM_EXPR_ENTRY (state->input_entry), state->sheet);
if (input_range == NULL) {
gtk_label_set_text (GTK_LABEL (state->warning),
_("The input range is invalid."));
gtk_widget_set_sensitive (state->ok_button, FALSE);
} else {
value_release (input_range);
gtk_label_set_text (GTK_LABEL (state->warning), "");
gtk_widget_set_sensitive (state->ok_button, TRUE);
}
}
/**
* random_cor_tool_update_sensitivity_cb:
* @dummy:
* @state:
*
* Update the dialog widgets sensitivity if the only items of interest
* are the standard input (one range) and output items.
**/
static void
random_cor_tool_update_sensitivity_cb (G_GNUC_UNUSED GtkWidget *dummy,
RandomCorToolState *state)
{
GnmValue *input_range;
gint height, width, count;
input_range = gnm_expr_entry_parse_as_value
(GNM_EXPR_ENTRY (state->base.input_entry), state->base.sheet);
if (input_range == NULL) {
gtk_label_set_text (GTK_LABEL (state->base.warning),
_("The matrix range is not valid."));
gtk_widget_set_sensitive (state->base.ok_button, FALSE);
return;
}
height = input_range->v_range.cell.b.row - input_range->v_range.cell.a.row;
width = input_range->v_range.cell.b.col - input_range->v_range.cell.a.col;
value_release (input_range);
if (height != width || height == 0) {
gtk_label_set_text (GTK_LABEL (state->base.warning),
_("The matrix must be symmetric positive-definite."));
gtk_widget_set_sensitive (state->base.ok_button, FALSE);
return;
}
if (!gnm_dao_is_ready (GNM_DAO (state->base.gdao))) {
gtk_label_set_text (GTK_LABEL (state->base.warning),
_("The output specification "
"is invalid."));
gtk_widget_set_sensitive (state->base.ok_button, FALSE);
return;
}
if (entry_to_int (GTK_ENTRY (state->count_entry), &count, FALSE) != 0 ||
count <= 0) {
gtk_label_set_text (GTK_LABEL (state->base.warning),
_("The number of random numbers requested is invalid."));
gtk_widget_set_sensitive (state->base.ok_button, FALSE);
return;
}
gtk_label_set_text (GTK_LABEL (state->base.warning), "");
gtk_widget_set_sensitive (state->base.ok_button, TRUE);
}
static void
cb_update_to_new_range (SortFlowState *state)
{
GnmValue *range;
range = gnm_expr_entry_parse_as_value
(GNM_EXPR_ENTRY (state->range_entry), state->sheet);
if (range == NULL) {
if (state->sel != NULL) {
value_release (state->sel);
state->sel = NULL;
gtk_list_store_clear (state->model);
state->sort_items = 0;
}
} else
translate_range (range, state);
set_button_sensitivity (state);
}
/**
* advanced_filter_update_sensitivity_cb:
* @dummy:
* @state:
*
* Update the dialog widgets sensitivity
**/
static void
advanced_filter_update_sensitivity_cb (G_GNUC_UNUSED GtkWidget *dummy,
AdvancedFilterState *state)
{
GnmValue *input_range = NULL;
GnmValue *criteria_range = NULL;
input_range = gnm_expr_entry_parse_as_value (
GNM_EXPR_ENTRY (state->input_entry), state->sheet);
if (input_range == NULL) {
gtk_label_set_text (GTK_LABEL (state->warning),
_("The list range is invalid."));
gtk_widget_set_sensitive (state->ok_button, FALSE);
return;
} else
value_release (input_range);
criteria_range = gnm_expr_entry_parse_as_value
(state->input_entry_2, state->sheet);
if (criteria_range == NULL) {
gtk_label_set_text (GTK_LABEL (state->warning),
_("The criteria range is invalid."));
gtk_widget_set_sensitive (state->ok_button, FALSE);
return;
} else
value_release (criteria_range);
if (!gnm_dao_is_ready (GNM_DAO (state->gdao))) {
gtk_label_set_text (GTK_LABEL (state->warning),
_("The output range is invalid."));
gtk_widget_set_sensitive (state->ok_button, FALSE);
return;
}
gtk_label_set_text (GTK_LABEL (state->warning), "");
gtk_widget_set_sensitive (state->ok_button, TRUE);
return;
}
static void
tabulate_ok_clicked (G_GNUC_UNUSED GtkWidget *widget, DialogState *dd)
{
GtkDialog *dialog = dd->dialog;
GnmCell *resultcell;
int dims = 0;
int row;
gboolean with_coordinates;
GnmTabulateInfo *data;
/* we might get the 4 below from the positon of some of the widgets inside the grid */
int nrows = 4;
GnmCell **cells;
gnm_float *minima, *maxima, *steps;
cells = g_new (GnmCell *, nrows);
minima = g_new (gnm_float, nrows);
maxima = g_new (gnm_float, nrows);
steps = g_new (gnm_float, nrows);
for (row = 1; row < nrows; row++) {
GtkEntry *e_w;
GnmExprEntry *w = GNM_EXPR_ENTRY (gtk_grid_get_child_at (dd->grid, COL_CELL, row + 1));
if (!w || gnm_expr_entry_is_blank (w))
continue;
cells[dims] = single_cell (dd->sheet, w);
if (!cells[dims]) {
go_gtk_notice_dialog (GTK_WINDOW (dd->dialog),
GTK_MESSAGE_ERROR,
_("You should introduce a single valid cell as dependency cell"));
gnm_expr_entry_grab_focus (GNM_EXPR_ENTRY (w), TRUE);
goto error;
}
if (gnm_cell_has_expr (cells[dims])) {
go_gtk_notice_dialog (GTK_WINDOW (dd->dialog),
GTK_MESSAGE_ERROR,
_("The dependency cells should not contain an expression"));
gnm_expr_entry_grab_focus (GNM_EXPR_ENTRY (w), TRUE);
goto error;
}
if (get_grid_float_entry (dd->grid, row, COL_MIN, cells[dims],
&(minima[dims]), &e_w, FALSE, 0.0)) {
go_gtk_notice_dialog (GTK_WINDOW (dd->dialog),
GTK_MESSAGE_ERROR,
_("You should introduce a valid number as minimum"));
focus_on_entry (e_w);
goto error;
}
if (get_grid_float_entry (dd->grid, row, COL_MAX, cells[dims],
&(maxima[dims]), &e_w, FALSE, 0.0)) {
go_gtk_notice_dialog (GTK_WINDOW (dd->dialog),
GTK_MESSAGE_ERROR,
_("You should introduce a valid number as maximum"));
focus_on_entry (e_w);
goto error;
}
if (maxima[dims] < minima[dims]) {
go_gtk_notice_dialog (GTK_WINDOW (dd->dialog),
GTK_MESSAGE_ERROR,
_("The maximum value should be bigger than the minimum"));
focus_on_entry (e_w);
goto error;
}
if (get_grid_float_entry (dd->grid, row, COL_STEP, cells[dims],
&(steps[dims]), &e_w, TRUE, 1.0)) {
go_gtk_notice_dialog (GTK_WINDOW (dd->dialog),
GTK_MESSAGE_ERROR,
_("You should introduce a valid number as step size"));
focus_on_entry (e_w);
goto error;
}
if (steps[dims] <= 0) {
go_gtk_notice_dialog (GTK_WINDOW (dd->dialog),
GTK_MESSAGE_ERROR,
_("The step size should be positive"));
focus_on_entry (e_w);
goto error;
}
dims++;
}
if (dims == 0) {
go_gtk_notice_dialog (GTK_WINDOW (dd->dialog),
GTK_MESSAGE_ERROR,
_("You should introduce one or more dependency cells"));
goto error;
}
{
resultcell = single_cell (dd->sheet, dd->resultrangetext);
if (!resultcell) {
go_gtk_notice_dialog (GTK_WINDOW (dd->dialog),
GTK_MESSAGE_ERROR,
_("You should introduce a single valid cell as result cell"));
gnm_expr_entry_grab_focus (dd->resultrangetext, TRUE);
goto error;
}
if (!gnm_cell_has_expr (resultcell)) {
go_gtk_notice_dialog (GTK_WINDOW (dd->dialog),
GTK_MESSAGE_ERROR,
_("The target cell should contain an expression"));
gnm_expr_entry_grab_focus (dd->resultrangetext, TRUE);
goto error;
}
}
{
int i = gnm_gui_group_value (dd->gui, mode_group);
with_coordinates = (i == -1) ? TRUE : (gboolean)i;
}
data = g_new (GnmTabulateInfo, 1);
data->target = resultcell;
data->dims = dims;
data->cells = cells;
data->minima = minima;
data->maxima = maxima;
data->steps = steps;
data->with_coordinates = with_coordinates;
if (!cmd_tabulate (GNM_WBC (dd->wbcg), data)) {
gtk_widget_destroy (GTK_WIDGET (dialog));
return;
}
g_free (data);
error:
g_free (minima);
g_free (maxima);
g_free (steps);
g_free (cells);
}
static void
dialog_init (SortFlowState *state)
{
GtkTable *table;
GtkWidget *scrolled;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
gboolean col_rb;
GnmRange const *range;
table = GTK_TABLE (go_gtk_builder_get_widget (state->gui, "cell_sort_options_table"));
/* setup range entry */
state->range_entry = gnm_expr_entry_new (state->wbcg, TRUE);
gnm_expr_entry_set_flags (state->range_entry,
GNM_EE_SINGLE_RANGE,
GNM_EE_MASK);
gtk_table_attach (table, GTK_WIDGET (state->range_entry),
2, 3, 1, 2,
GTK_EXPAND | GTK_FILL, 0,
0, 0);
gnumeric_editable_enters (GTK_WINDOW (state->dialog),
GTK_WIDGET (state->range_entry));
gnm_expr_entry_set_update_policy (state->range_entry, GTK_UPDATE_DISCONTINUOUS);
gtk_widget_show (GTK_WIDGET (state->range_entry));
g_signal_connect_swapped (G_OBJECT (state->range_entry),
"changed",
G_CALLBACK (cb_update_to_new_range), state);
state->locale_selector = GO_LOCALE_SEL (go_locale_sel_new ());
gtk_widget_show_all (GTK_WIDGET (state->locale_selector));
gtk_table_attach (table, GTK_WIDGET (state->locale_selector),
2, 3, 5, 6,
GTK_EXPAND | GTK_FILL, 0,
0, 0);
table = GTK_TABLE (go_gtk_builder_get_widget (state->gui, "cell_sort_spec_table"));
/* setup add entry */
state->add_entry = gnm_expr_entry_new (state->wbcg, TRUE);
gnm_expr_entry_set_flags (state->add_entry,
GNM_EE_SINGLE_RANGE,
GNM_EE_MASK);
gtk_table_attach (table, GTK_WIDGET (state->add_entry),
1, 2, 2, 3,
GTK_EXPAND | GTK_FILL, 0,
0, 0);
gnumeric_editable_enters (GTK_WINDOW (state->dialog),
GTK_WIDGET (state->add_entry));
gtk_widget_show (GTK_WIDGET (state->add_entry));
/* Set-up tree view */
scrolled = go_gtk_builder_get_widget (state->gui, "scrolled_cell_sort_list");
state->model = gtk_list_store_new (NUM_COLMNS, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_BOOLEAN,
GDK_TYPE_PIXBUF, G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
G_TYPE_INT);
state->treeview = GTK_TREE_VIEW (
gtk_tree_view_new_with_model (GTK_TREE_MODEL (state->model)));
state->selection = gtk_tree_view_get_selection (state->treeview);
gtk_tree_selection_set_mode (state->selection, GTK_SELECTION_BROWSE);
g_signal_connect_swapped (state->selection,
"changed",
G_CALLBACK (cb_sort_selection_changed), state);
state->header_column = gtk_tree_view_column_new_with_attributes (_("Header"),
gtk_cell_renderer_text_new (),
"text", ITEM_HEADER, NULL);
gtk_tree_view_append_column (state->treeview, state->header_column);
column = gtk_tree_view_column_new_with_attributes (_("Row/Column"),
gtk_cell_renderer_text_new (),
"text", ITEM_NAME, NULL);
gtk_tree_view_append_column (state->treeview, column);
renderer = gnumeric_cell_renderer_toggle_new ();
g_signal_connect (G_OBJECT (renderer),
"toggled",
G_CALLBACK (cb_toggled_descending), state);
column = gtk_tree_view_column_new_with_attributes ("",
renderer,
"active", ITEM_DESCENDING,
"pixbuf", ITEM_DESCENDING_IMAGE,
NULL);
gtk_tree_view_append_column (state->treeview, column);
renderer = gtk_cell_renderer_toggle_new ();
g_signal_connect (G_OBJECT (renderer),
"toggled",
G_CALLBACK (cb_toggled_case_sensitive), state);
column = gtk_tree_view_column_new_with_attributes (_("Case Sensitive"),
renderer,
"active", ITEM_CASE_SENSITIVE, NULL);
gtk_tree_view_append_column (state->treeview, column);
gtk_tree_view_columns_autosize (state->treeview);
g_signal_connect (G_OBJECT (state->treeview),
"key_press_event",
G_CALLBACK (cb_treeview_keypress), state);
g_signal_connect (G_OBJECT (state->treeview),
"button_press_event",
G_CALLBACK (cb_treeview_button_press), state);
#if 0
/* We are currently not supporting `by-value' vs not. */
renderer = gtk_cell_renderer_toggle_new ();
g_signal_connect (G_OBJECT (renderer),
"toggled",
G_CALLBACK (cb_toggled_sort_by_value), state);
column = gtk_tree_view_column_new_with_attributes (_("By Value"),
renderer,
"active", ITEM_SORT_BY_VALUE, NULL);
gtk_tree_view_append_column (state->treeview, column);
#endif
gtk_tree_view_set_reorderable (state->treeview,TRUE);
gtk_container_add (GTK_CONTAINER (scrolled), GTK_WIDGET (state->treeview));
gtk_widget_show (GTK_WIDGET (state->treeview));
/* Set-up other widgets */
state->cell_sort_row_rb = go_gtk_builder_get_widget (state->gui, "cell_sort_row_rb");
state->cell_sort_col_rb = go_gtk_builder_get_widget (state->gui, "cell_sort_col_rb");
g_signal_connect_swapped (G_OBJECT (state->cell_sort_row_rb),
"toggled",
G_CALLBACK (cb_update_to_new_range), state);
state->cell_sort_header_check = go_gtk_builder_get_widget (state->gui,
"cell_sort_header_check");
g_signal_connect_swapped (G_OBJECT (state->cell_sort_header_check),
"toggled",
G_CALLBACK (cb_sort_header_check), state);
state->retain_format_check = go_gtk_builder_get_widget (state->gui,
"retain_format_button");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (state->retain_format_check),
gnm_conf_get_core_sort_default_retain_formats ());
/* Set-up buttons */
state->up_button = go_gtk_builder_get_widget (state->gui, "up_button");
g_signal_connect_swapped (G_OBJECT (state->up_button),
"clicked",
G_CALLBACK (cb_up), state);
state->down_button = go_gtk_builder_get_widget (state->gui, "down_button");
g_signal_connect_swapped (G_OBJECT (state->down_button),
"clicked",
G_CALLBACK (cb_down), state);
state->add_button = go_gtk_builder_get_widget (state->gui, "add_button");
g_signal_connect_swapped (G_OBJECT (state->add_button),
"clicked",
G_CALLBACK (cb_add_clicked), state);
gtk_widget_set_sensitive (state->add_button, TRUE);
state->delete_button = go_gtk_builder_get_widget (state->gui, "delete_button");
g_signal_connect (G_OBJECT (state->delete_button),
"clicked",
G_CALLBACK (cb_delete_clicked), state);
gtk_widget_set_sensitive (state->delete_button, FALSE);
state->clear_button = go_gtk_builder_get_widget (state->gui, "clear_button");
g_signal_connect_swapped (G_OBJECT (state->clear_button),
"clicked",
G_CALLBACK (cb_clear_clicked), state);
gtk_widget_set_sensitive (state->clear_button, FALSE);
gtk_button_set_alignment (GTK_BUTTON (state->up_button), 0., .5);
gtk_button_set_alignment (GTK_BUTTON (state->down_button), 0., .5);
gtk_button_set_alignment (GTK_BUTTON (state->add_button), 0., .5);
gtk_button_set_alignment (GTK_BUTTON (state->delete_button), 0., .5);
gtk_button_set_alignment (GTK_BUTTON (state->clear_button), 0., .5);
gnumeric_init_help_button (
go_gtk_builder_get_widget (state->gui, "help_button"),
GNUMERIC_HELP_LINK_CELL_SORT);
state->ok_button = go_gtk_builder_get_widget (state->gui, "ok_button");
g_signal_connect_swapped (G_OBJECT (state->ok_button),
"clicked",
G_CALLBACK (cb_dialog_ok_clicked), state);
state->cancel_button = go_gtk_builder_get_widget (state->gui, "cancel_button");
g_signal_connect (G_OBJECT (state->cancel_button),
"clicked",
G_CALLBACK (cb_dialog_cancel_clicked), state);
gnm_dialog_setup_destroy_handlers (GTK_DIALOG (state->dialog),
state->wbcg,
GNM_DIALOG_DESTROY_CURRENT_SHEET_REMOVED);
/* Finish dialog signals */
wbc_gtk_attach_guru (state->wbcg, state->dialog);
g_object_set_data_full (G_OBJECT (state->dialog),
"state", state, (GDestroyNotify) cb_dialog_destroy);
range = dialog_load_selection (state, &col_rb);
cb_sort_selection_changed (state);
gnm_expr_entry_grab_focus(GNM_EXPR_ENTRY (state->add_entry), TRUE);
}
/**
* kaplan_meier_tool_update_sensitivity_cb:
* @dummy:
* @state:
*
* Update the dialog widgets sensitivity
**/
static void
kaplan_meier_tool_update_sensitivity_cb (G_GNUC_UNUSED GtkWidget *dummy,
KaplanMeierToolState *state)
{
gboolean censorship;
gboolean groups;
GnmValue *input_range;
GnmValue *input_range_2 = NULL;
int height, width;
censorship = gtk_toggle_button_get_active (
GTK_TOGGLE_BUTTON (state->censorship_button));
groups = gtk_toggle_button_get_active (
GTK_TOGGLE_BUTTON (state->groups_check));
gtk_widget_set_sensitive (state->tick_button, censorship);
input_range = gnm_expr_entry_parse_as_value
(GNM_EXPR_ENTRY (state->base.input_entry), state->base.sheet);
if (input_range == NULL) {
gtk_label_set_text (GTK_LABEL (state->base.warning),
_("The time column is not valid."));
gtk_widget_set_sensitive (state->base.ok_button, FALSE);
return;
}
height = input_range->v_range.cell.b.row - input_range->v_range.cell.a.row;
width = input_range->v_range.cell.b.col - input_range->v_range.cell.a.col;
value_release (input_range);
if (width != 0) {
gtk_label_set_text (GTK_LABEL (state->base.warning),
_("The time column should be part of a single column."));
gtk_widget_set_sensitive (state->base.ok_button, FALSE);
return;
}
if (censorship) {
input_range_2 = gnm_expr_entry_parse_as_value
(GNM_EXPR_ENTRY (state->base.input_entry_2), state->base.sheet);
if (input_range_2 == NULL) {
gtk_label_set_text (GTK_LABEL (state->base.warning),
_("The censorship column is not valid."));
gtk_widget_set_sensitive (state->base.ok_button, FALSE);
return;
}
if (input_range_2->v_range.cell.b.col != input_range_2->v_range.cell.a.col) {
gtk_label_set_text (GTK_LABEL (state->base.warning),
_("The censorship column should be part of a single column."));
gtk_widget_set_sensitive (state->base.ok_button, FALSE);
value_release (input_range_2);
return;
}
if (input_range_2->v_range.cell.b.row - input_range_2->v_range.cell.a.row != height) {
gtk_label_set_text (GTK_LABEL (state->base.warning),
_("The censorship and time columns should have the same height."));
gtk_widget_set_sensitive (state->base.ok_button, FALSE);
value_release (input_range_2);
return;
}
value_release (input_range_2);
}
if (groups) {
input_range_2 = gnm_expr_entry_parse_as_value
(GNM_EXPR_ENTRY (state->groups_input), state->base.sheet);
if (input_range_2 == NULL) {
gtk_label_set_text (GTK_LABEL (state->base.warning),
_("The groups column is not valid."));
gtk_widget_set_sensitive (state->base.ok_button, FALSE);
return;
}
if (input_range_2->v_range.cell.b.col != input_range_2->v_range.cell.a.col) {
gtk_label_set_text (GTK_LABEL (state->base.warning),
_("The groups column should be part of a single column."));
gtk_widget_set_sensitive (state->base.ok_button, FALSE);
value_release (input_range_2);
return;
}
if (input_range_2->v_range.cell.b.row - input_range_2->v_range.cell.a.row != height) {
gtk_label_set_text (GTK_LABEL (state->base.warning),
_("The groups and time columns should have the same height."));
gtk_widget_set_sensitive (state->base.ok_button, FALSE);
value_release (input_range_2);
return;
}
value_release (input_range_2);
}
if (!gnm_dao_is_ready (GNM_DAO (state->base.gdao))) {
gtk_label_set_text (GTK_LABEL (state->base.warning),
_("The output specification "
"is invalid."));
gtk_widget_set_sensitive (state->base.ok_button, FALSE);
return;
}
gtk_label_set_text (GTK_LABEL (state->base.warning), "");
gtk_widget_set_sensitive (state->base.ok_button, TRUE);
return;
}
/**
* dialog_kaplan_meier_tool:
* @wbcg:
* @sheet:
*
* Show the dialog (guru).
*
**/
int
dialog_kaplan_meier_tool (WBCGtk *wbcg, Sheet *sheet)
{
KaplanMeierToolState *state;
GtkWidget *widget;
char const * plugins[] = { "Gnumeric_fnstat",
"Gnumeric_fnlookup",
"Gnumeric_fnmath",
"Gnumeric_fninfo",
"Gnumeric_fnlogical",
NULL};
if ((wbcg == NULL) ||
gnm_check_for_plugins_missing (plugins, wbcg_toplevel (wbcg)))
return 1;
/* Only pop up one copy per workbook */
if (gnumeric_dialog_raise_if_exists (wbcg, KAPLAN_MEIER_KEY))
return 0;
state = g_new0 (KaplanMeierToolState, 1);
if (dialog_tool_init (&state->base, wbcg, sheet,
GNUMERIC_HELP_LINK_KAPLAN_MEIER,
"kaplan-meier.glade", "KaplanMeier",
_("Could not create the Kaplan Meier Tool dialog."),
KAPLAN_MEIER_KEY,
G_CALLBACK (kaplan_meier_tool_ok_clicked_cb), NULL,
G_CALLBACK (kaplan_meier_tool_update_sensitivity_cb),
0))
return 0;
state->censorship_button = GTK_WIDGET (glade_xml_get_widget
(state->base.gui,
"censor-button"));
state->censor_spin_from = GTK_WIDGET (glade_xml_get_widget
(state->base.gui,
"censored-spinbutton1"));
gtk_spin_button_set_range (GTK_SPIN_BUTTON (state->censor_spin_from), 0.,G_MAXSHORT);
state->censor_spin_to = GTK_WIDGET (glade_xml_get_widget
(state->base.gui,
"censored-spinbutton2"));
gtk_spin_button_set_range (GTK_SPIN_BUTTON (state->censor_spin_to), 0.,G_MAXSHORT);
state->graph_button = GTK_WIDGET (glade_xml_get_widget
(state->base.gui,
"graph-button"));
state->tick_button = GTK_WIDGET (glade_xml_get_widget
(state->base.gui,
"tick-button"));
state->add_group_button = GTK_WIDGET (glade_xml_get_widget
(state->base.gui,
"add-button"));
state->remove_group_button = GTK_WIDGET (glade_xml_get_widget
(state->base.gui,
"remove-button"));
state->std_error_button = GTK_WIDGET (glade_xml_get_widget
(state->base.gui,
"std-error-button"));
state->logrank_button = GTK_WIDGET (glade_xml_get_widget
(state->base.gui,
"logrank-button"));
state->groups_check = GTK_WIDGET (glade_xml_get_widget
(state->base.gui,
"groups-check"));
state->groups_table = GTK_WIDGET (glade_xml_get_widget
(state->base.gui,
"groups-table"));
state->groups_input = gnm_expr_entry_new (state->base.wbcg, TRUE);
gnm_expr_entry_set_flags (state->groups_input, GNM_EE_FORCE_ABS_REF,
GNM_EE_MASK);
gtk_table_attach (GTK_TABLE (state->groups_table), GTK_WIDGET (state->groups_input),
1, 3, 0, 1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
dialog_kaplan_meier_tool_setup_treeview (state);
g_signal_connect_after (G_OBJECT (state->groups_check),
"toggled",
G_CALLBACK (kaplan_meier_tool_update_sensitivity_cb), state);
g_signal_connect_after (G_OBJECT (state->censorship_button),
"toggled",
G_CALLBACK (kaplan_meier_tool_update_sensitivity_cb), state);
g_signal_connect_after (G_OBJECT (state->graph_button),
"toggled",
G_CALLBACK (kaplan_meier_tool_update_sensitivity_cb), state);
g_signal_connect_after (G_OBJECT (state->std_error_button),
"toggled",
G_CALLBACK (kaplan_meier_tool_update_sensitivity_cb), state);
g_signal_connect_after (G_OBJECT (state->groups_input),
"changed",
G_CALLBACK (kaplan_meier_tool_update_sensitivity_cb),
state);
g_signal_connect_after (G_OBJECT (state->groups_check),
"toggled",
G_CALLBACK (kaplan_meier_tool_update_groups_sensitivity_cb), state);
g_signal_connect_after (G_OBJECT (state->tick_button),
"toggled",
G_CALLBACK (kaplan_meier_tool_set_graph_cb), state);
g_signal_connect_after (G_OBJECT (state->add_group_button),
"clicked",
G_CALLBACK (kaplan_meier_tool_add_group_cb), state);
g_signal_connect_after (G_OBJECT (state->remove_group_button),
"clicked",
G_CALLBACK (kaplan_meier_tool_remove_group_cb), state);
g_signal_connect_after (G_OBJECT (state->censor_spin_from),
"value-changed",
G_CALLBACK (kaplan_meier_tool_set_censor_from_cb), state);
g_signal_connect_after (G_OBJECT (state->censor_spin_to),
"value-changed",
G_CALLBACK (kaplan_meier_tool_set_censor_cb), state);
g_signal_connect (G_OBJECT
(gnm_expr_entry_get_entry (
GNM_EXPR_ENTRY (state->base.input_entry_2))),
"focus-in-event",
G_CALLBACK (kaplan_meier_tool_set_censorship_cb), state);
g_signal_connect (G_OBJECT
(gnm_expr_entry_get_entry (
GNM_EXPR_ENTRY (state->groups_input))),
"focus-in-event",
G_CALLBACK (kaplan_meier_tool_set_groups_cb), state);
gnumeric_editable_enters (GTK_WINDOW (state->base.dialog),
GTK_WIDGET (state->groups_input));
widget = glade_xml_get_widget (state->base.gui, "groups-label");
gtk_label_set_mnemonic_widget (GTK_LABEL (widget),
GTK_WIDGET (state->groups_input));
go_atk_setup_label (widget, GTK_WIDGET (state->groups_input));
gnm_dao_set_put (GNM_DAO (state->base.gdao), TRUE, TRUE);
kaplan_meier_tool_update_sensitivity_cb (NULL, state);
kaplan_meier_tool_update_groups_sensitivity_cb (NULL, state);
tool_load_selection ((GenericToolState *)state, TRUE);
gtk_widget_show_all (GTK_WIDGET (state->base.dialog));
/* And to hide the in-place button again */
gnm_dao_set_inplace ( GNM_DAO (state->base.gdao), NULL);
return 0;
}
/**
* scenarios_ok_clicked_cb:
* @button:
* @state:
*
* Run the scenario manager tool.
**/
static void
scenario_add_ok_clicked_cb (G_GNUC_UNUSED GtkWidget *button,
ScenariosState *state)
{
data_analysis_output_t dao;
WorkbookControl *wbc;
gchar *name;
gchar *comment;
GnmValue *cell_range;
GtkWidget *entry, *comment_view;
GtkTextBuffer *buf;
GtkTextIter start, end;
GnmScenario *sc;
GnmSheetRange sr;
cell_range = gnm_expr_entry_parse_as_value
(GNM_EXPR_ENTRY (state->base.input_entry), state->base.sheet);
if (!cell_range || !gnm_sheet_range_from_value (&sr, cell_range)) {
go_gtk_notice_dialog (GTK_WINDOW (state->base.dialog),
GTK_MESSAGE_ERROR,
_("Invalid changing cells"));
gnm_expr_entry_grab_focus (state->base.input_entry, TRUE);
return;
}
if (sr.sheet && sr.sheet != state->base.sheet) {
go_gtk_notice_dialog (GTK_WINDOW (state->base.dialog),
GTK_MESSAGE_ERROR,
_("Changing cells should be on the current "
"sheet only."));
gnm_expr_entry_grab_focus (state->base.input_entry, TRUE);
goto out;
}
entry = go_gtk_builder_get_widget (state->base.gui, "name_entry");
name = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
if (scenario_name_used (state->base.sheet->scenarios, name)) {
g_free (name);
go_gtk_notice_dialog (GTK_WINDOW (state->base.dialog),
GTK_MESSAGE_ERROR,
_("Scenario name already used"));
goto out;
} else if (check_name (name)) {
g_free (name);
go_gtk_notice_dialog (GTK_WINDOW (state->base.dialog),
GTK_MESSAGE_ERROR,
_("Invalid scenario name"));
goto out;
}
comment_view = go_gtk_builder_get_widget (state->base.gui, "comment_view");
buf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (comment_view));
gtk_text_buffer_get_start_iter (buf, &start);
gtk_text_buffer_get_end_iter (buf, &end);
comment = g_strdup (gtk_text_buffer_get_text (buf, &start, &end,
FALSE));
dao_init_new_sheet (&dao);
dao.sheet = state->base.sheet;
wbc = WORKBOOK_CONTROL (state->base.wbcg);
sc = gnm_sheet_scenario_new (state->base.sheet, name);
if (comment && comment[0])
gnm_scenario_set_comment (sc, comment);
gnm_scenario_add_area (sc, &sr);
cmd_scenario_add (wbc, sc, state->base.sheet);
g_free (name);
g_free (comment);
gtk_widget_destroy (state->base.dialog);
out:
value_release (cell_range);
return;
}
/**
* advanced_filter_ok_clicked_cb:
* @button:
* @state:
*
* Retrieve the information from the dialog and call the advanced_filter.
* Note that we assume that the ok_button is only active if the entry fields
* contain sensible data.
**/
static void
advanced_filter_ok_clicked_cb (G_GNUC_UNUSED GtkWidget *button,
AdvancedFilterState *state)
{
data_analysis_output_t *dao;
GnmValue *input;
GnmValue *criteria;
char *text;
GtkWidget *w;
int err = 0;
gboolean unique;
input = gnm_expr_entry_parse_as_value (
GNM_EXPR_ENTRY (state->input_entry), state->sheet);
criteria = gnm_expr_entry_parse_as_value
(state->input_entry_2, state->sheet);
dao = parse_output ((GenericToolState *) state, NULL);
w = go_gtk_builder_get_widget (state->gui, "unique-button");
unique = (1 == gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)));
if (dao->type == InPlaceOutput)
err = advanced_filter (WORKBOOK_CONTROL (state->wbcg),
dao, input, criteria, unique);
else {
analysis_tools_data_advanced_filter_t *
data = g_new0 (analysis_tools_data_advanced_filter_t, 1);
data->base.wbc = WORKBOOK_CONTROL (state->wbcg);
data->base.range_1 = input;
data->base.range_2 = criteria;
data->unique_only_flag = unique;
if (cmd_analysis_tool (WORKBOOK_CONTROL (state->wbcg), state->sheet,
dao, data, analysis_tool_advanced_filter_engine, FALSE)) {
err = data->base.err;
g_free (data);
} else
err = analysis_tools_noerr;
}
if (dao->type == InPlaceOutput || err != analysis_tools_noerr) {
value_release (input);
value_release (criteria);
g_free (dao);
}
switch (err) {
case analysis_tools_noerr:
gtk_widget_destroy (state->dialog);
break;
case analysis_tools_invalid_field:
error_in_entry ((GenericToolState *) state,
GTK_WIDGET (state->input_entry_2),
_("The given criteria are invalid."));
break;
case analysis_tools_no_records_found:
go_gtk_notice_nonmodal_dialog ((GtkWindow *) state->dialog,
&(state->warning_dialog),
GTK_MESSAGE_INFO,
_("No matching records were found."));
break;
default:
text = g_strdup_printf (_("An unexpected error has occurred: "
"%d."), err);
error_in_entry ((GenericToolState *) state,
GTK_WIDGET (state->input_entry), text);
g_free (text);
break;
}
return;
}
static void
cb_add_clicked (SortFlowState *state)
{
GnmValue *range_add;
GnmSheetRange grange_sort, grange_add;
GnmRange intersection;
int start;
int end;
int index;
int i;
gboolean had_items = (state->sort_items > 0);
range_add = gnm_expr_entry_parse_as_value
(GNM_EXPR_ENTRY (state->add_entry), state->sheet);
if (range_add == NULL) {
show_add_menu (state);
return;
}
g_return_if_fail (range_add != NULL && state->sel != NULL);
gnm_sheet_range_from_value (&grange_sort, state->sel);
gnm_sheet_range_from_value (&grange_add, range_add);
value_release (range_add);
if (range_intersection (&intersection, &grange_sort.range, &grange_add.range)) {
if (state->is_cols) {
start = intersection.start.col;
end = intersection.end.col;
index = state->sel->v_range.cell.a.row;
} else {
start = intersection.start.row;
end = intersection.end.row;
index = state->sel->v_range.cell.a.col;
}
for (i = start; i <= end; i++) {
int item = 0;
GtkTreeIter iter;
gboolean found = FALSE;
gint number;
while (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (state->model),
&iter, NULL, item)) {
gtk_tree_model_get (GTK_TREE_MODEL (state->model), &iter,
ITEM_NUMBER, &number,
-1);
item++;
if (number == i) {
found = TRUE;
break;
}
}
if (!found) {
append_data (state, i, index);
}
}
if (!had_items && (state->sort_items > 0))
set_button_sensitivity(state);
} else
show_add_menu (state);
gnm_expr_entry_load_from_text (GNM_EXPR_ENTRY (state->add_entry), "");
}
/**
* dialog_init:
* @state:
*
* Create the dialog (guru).
*
**/
static gboolean
dialog_init (SolverState *state)
{
GtkGrid *grid;
GnmSolverParameters *param;
GtkCellRenderer *renderer;
GtkListStore *store;
GtkTreeViewColumn *column;
GSList *cl;
GnmCell *target_cell;
GnmValue const *input;
int i;
param = state->sheet->solver_parameters;
state->gui = gnm_gtk_builder_load ("solver.ui", NULL, GO_CMD_CONTEXT (state->wbcg));
if (state->gui == NULL)
return TRUE;
state->dialog = go_gtk_builder_get_widget (state->gui, "Solver");
if (state->dialog == NULL)
return TRUE;
state->notebook = go_gtk_builder_get_widget (state->gui, "solver_notebook");
/* buttons */
state->solve_button = go_gtk_builder_get_widget (state->gui, "solvebutton");
g_signal_connect (G_OBJECT (state->solve_button), "clicked",
G_CALLBACK (cb_dialog_solve_clicked), state);
state->close_button = go_gtk_builder_get_widget (state->gui, "closebutton");
g_signal_connect (G_OBJECT (state->close_button), "clicked",
G_CALLBACK (cb_dialog_close_clicked), state);
state->help_button = go_gtk_builder_get_widget (state->gui, "helpbutton");
gnm_init_help_button (state->help_button, GNUMERIC_HELP_LINK_SOLVER);
state->add_button = go_gtk_builder_get_widget (state->gui, "addbutton");
gtk_button_set_alignment (GTK_BUTTON (state->add_button), 0.5, .5);
g_signal_connect_swapped (G_OBJECT (state->add_button), "clicked",
G_CALLBACK (cb_dialog_add_clicked), state);
state->change_button = go_gtk_builder_get_widget (state->gui,
"changebutton");
g_signal_connect (G_OBJECT (state->change_button), "clicked",
G_CALLBACK (cb_dialog_change_clicked), state);
state->delete_button = go_gtk_builder_get_widget (state->gui,
"deletebutton");
gtk_button_set_alignment (GTK_BUTTON (state->delete_button), 0.5, .5);
g_signal_connect (G_OBJECT (state->delete_button), "clicked",
G_CALLBACK (cb_dialog_delete_clicked), state);
state->stop_button = go_gtk_builder_get_widget (state->gui, "stopbutton");
g_signal_connect_swapped (G_OBJECT (state->stop_button),
"clicked", G_CALLBACK (cb_stop_solver),
state);
/* target_entry */
grid = GTK_GRID (go_gtk_builder_get_widget (state->gui,
"parameter-grid"));
state->target_entry = gnm_expr_entry_new (state->wbcg, TRUE);
gnm_expr_entry_set_flags (state->target_entry,
GNM_EE_SINGLE_RANGE |
GNM_EE_FORCE_ABS_REF |
GNM_EE_SHEET_OPTIONAL, GNM_EE_MASK);
gtk_widget_set_hexpand (GTK_WIDGET (state->target_entry), TRUE);
gtk_grid_attach (grid, GTK_WIDGET (state->target_entry), 1, 0, 2, 1);
gnm_editable_enters (GTK_WINDOW (state->dialog),
GTK_WIDGET (state->target_entry));
gtk_widget_show (GTK_WIDGET (state->target_entry));
g_signal_connect_after (G_OBJECT (state->target_entry), "changed",
G_CALLBACK (dialog_set_main_button_sensitivity),
state);
/* change_cell_entry */
state->change_cell_entry = gnm_expr_entry_new (state->wbcg, TRUE);
gnm_expr_entry_set_flags (state->change_cell_entry,
GNM_EE_SINGLE_RANGE |
GNM_EE_FORCE_ABS_REF |
GNM_EE_SHEET_OPTIONAL, GNM_EE_MASK);
gtk_widget_set_hexpand (GTK_WIDGET (state->change_cell_entry), TRUE);
gtk_grid_attach (grid,
GTK_WIDGET (state->change_cell_entry), 1, 2, 2, 1);
gnm_editable_enters (GTK_WINDOW (state->dialog),
GTK_WIDGET (state->change_cell_entry));
gtk_widget_show (GTK_WIDGET (state->change_cell_entry));
g_signal_connect_after (G_OBJECT (state->change_cell_entry), "changed",
G_CALLBACK (dialog_set_main_button_sensitivity), state);
/* Algorithm */
state->algorithm_combo = GTK_COMBO_BOX
(go_gtk_builder_get_widget (state->gui, "algorithm_combo"));
renderer = (GtkCellRenderer*) gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (state->algorithm_combo), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (state->algorithm_combo), renderer,
"text", 0,
NULL);
fill_algorithm_combo (state, param->options.model_type);
for (i = 0; model_type_group[i]; i++) {
const char *bname = model_type_group[i];
GtkWidget *w = go_gtk_builder_get_widget(state->gui, bname);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w),
param->options.model_type ==
(GnmSolverModelType)i);
g_signal_connect (G_OBJECT (w), "clicked",
G_CALLBACK (cb_dialog_model_type_clicked), state);
}
/* Options */
state->max_iter_entry = go_gtk_builder_get_widget (state->gui,
"max_iter_entry");
gtk_spin_button_set_value (GTK_SPIN_BUTTON (state->max_iter_entry),
param->options.max_iter);
state->max_time_entry = go_gtk_builder_get_widget (state->gui,
"max_time_entry");
gtk_spin_button_set_value (GTK_SPIN_BUTTON (state->max_time_entry),
param->options.max_time_sec);
state->gradient_order_entry = go_gtk_builder_get_widget (state->gui,
"gradient_order_entry");
gtk_spin_button_set_value (GTK_SPIN_BUTTON (state->gradient_order_entry),
param->options.gradient_order);
/* lhs_entry */
grid = GTK_GRID (go_gtk_builder_get_widget (state->gui,
"constraints-grid"));
state->lhs.entry = gnm_expr_entry_new (state->wbcg, TRUE);
gnm_expr_entry_set_flags (state->lhs.entry,
GNM_EE_SINGLE_RANGE |
GNM_EE_FORCE_ABS_REF |
GNM_EE_SHEET_OPTIONAL, GNM_EE_MASK);
gtk_widget_set_hexpand (GTK_WIDGET (state->lhs.entry), TRUE);
gtk_grid_attach (grid, GTK_WIDGET (state->lhs.entry), 0, 4, 1, 1);
state->lhs.label = go_gtk_builder_get_widget (state->gui, "lhs_label");
gtk_label_set_mnemonic_widget (GTK_LABEL (state->lhs.label),
GTK_WIDGET (state->lhs.entry));
gtk_widget_show (GTK_WIDGET (state->lhs.entry));
g_signal_connect_after (G_OBJECT (state->lhs.entry),
"changed",
G_CALLBACK (dialog_set_sec_button_sensitivity), state);
g_signal_connect_swapped (
gnm_expr_entry_get_entry (GNM_EXPR_ENTRY (state->lhs.entry)),
"activate", G_CALLBACK (cb_dialog_add_clicked), state);
/* rhs_entry */
state->rhs.entry = gnm_expr_entry_new (state->wbcg, TRUE);
gnm_expr_entry_set_flags (state->rhs.entry,
GNM_EE_SINGLE_RANGE |
GNM_EE_FORCE_ABS_REF |
GNM_EE_SHEET_OPTIONAL |
GNM_EE_CONSTANT_ALLOWED,
GNM_EE_MASK);
gtk_widget_set_hexpand (GTK_WIDGET (state->rhs.entry), TRUE);
gtk_grid_attach (grid, GTK_WIDGET (state->rhs.entry), 2, 4, 1, 1);
gtk_widget_show (GTK_WIDGET (state->rhs.entry));
state->rhs.label = go_gtk_builder_get_widget (state->gui, "rhs_label");
gtk_label_set_mnemonic_widget (
GTK_LABEL (state->rhs.label), GTK_WIDGET (state->rhs.entry));
g_signal_connect_after (G_OBJECT (state->rhs.entry),
"changed",
G_CALLBACK (dialog_set_sec_button_sensitivity), state);
g_signal_connect_swapped (
gnm_expr_entry_get_entry (GNM_EXPR_ENTRY (state->rhs.entry)),
"activate", G_CALLBACK (cb_dialog_add_clicked), state);
/* type_menu */
state->type_combo = GTK_COMBO_BOX
(go_gtk_builder_get_widget (state->gui, "type_menu"));
gtk_combo_box_set_active (state->type_combo, 0);
g_signal_connect (state->type_combo, "changed",
G_CALLBACK (dialog_set_sec_button_sensitivity),
state);
/* constraint_list */
state->constraint_list = GTK_TREE_VIEW (go_gtk_builder_get_widget
(state->gui, "constraint_list"));
state->constr = NULL;
g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (state->constraint_list)), "changed",
G_CALLBACK (constraint_select_click), state);
gtk_tree_view_set_reorderable (state->constraint_list, TRUE);
store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER);
gtk_tree_view_set_model (state->constraint_list, GTK_TREE_MODEL(store));
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (
_("Subject to the Constraints:"),
renderer, "text", 0, NULL);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_append_column (state->constraint_list, column);
{
GtkWidget *w = GTK_WIDGET (state->constraint_list);
int width, height, vsep;
PangoLayout *layout =
gtk_widget_create_pango_layout (w, "Mg19");
gtk_widget_style_get (w,
"vertical_separator", &vsep,
NULL);
pango_layout_get_pixel_size (layout, &width, &height);
gtk_widget_set_size_request (w,
-1,
(2 * height + vsep) * (4 + 1));
g_object_unref (layout);
}
/* Loading the old solver specs... from param */
for (cl = param->constraints; cl; cl = cl->next) {
GnmSolverConstraint const *c = cl->data;
GtkTreeIter iter;
char *str;
gtk_list_store_append (store, &iter);
str = gnm_solver_constraint_as_str (c, state->sheet);
gtk_list_store_set (store, &iter, 0, str, 1, c, -1);
g_free (str);
}
g_object_unref (store);
INIT_BOOL_ENTRY ("autoscale_button", options.automatic_scaling);
INIT_BOOL_ENTRY ("non_neg_button", options.assume_non_negative);
INIT_BOOL_ENTRY ("all_int_button", options.assume_discrete);
INIT_BOOL_ENTRY ("program", options.program_report);
INIT_BOOL_ENTRY ("sensitivity", options.sensitivity_report);
input = gnm_solver_param_get_input (param);
if (input != NULL)
gnm_expr_entry_load_from_text (state->change_cell_entry,
value_peek_string (input));
target_cell = gnm_solver_param_get_target_cell (param);
if (target_cell)
gnm_expr_entry_load_from_text (state->target_entry,
cell_name (target_cell));
else {
SheetView *sv = wb_control_cur_sheet_view
(GNM_WBC (state->wbcg));
if (sv) {
GnmRange first = {sv->edit_pos, sv->edit_pos};
gnm_expr_entry_load_from_range (state->target_entry,
state->sheet, &first);
}
}
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (
go_gtk_builder_get_widget(state->gui, "max_button")),
param->problem_type == GNM_SOLVER_MAXIMIZE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (
go_gtk_builder_get_widget(state->gui, "min_button")),
param->problem_type == GNM_SOLVER_MINIMIZE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (
go_gtk_builder_get_widget(state->gui, "no_scenario")),
! param->options.add_scenario);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (
go_gtk_builder_get_widget(state->gui, "optimal_scenario")),
param->options.add_scenario);
state->scenario_name_entry = go_gtk_builder_get_widget
(state->gui, "scenario_name_entry");
gtk_entry_set_text (GTK_ENTRY (state->scenario_name_entry),
param->options.scenario_name);
state->run.status_widget = go_gtk_builder_get_widget (state->gui, "solver_status_label");
state->run.problem_status_widget = go_gtk_builder_get_widget (state->gui, "problem_status_label");
state->run.objective_value_widget = go_gtk_builder_get_widget (state->gui, "objective_value_label");
state->run.timer_widget = go_gtk_builder_get_widget (state->gui, "elapsed_time_label");
state->run.spinner = go_gtk_builder_get_widget (state->gui, "run_spinner");
/* Done */
gnm_expr_entry_grab_focus (state->target_entry, FALSE);
wbcg_set_entry (state->wbcg, state->target_entry);
dialog_set_main_button_sensitivity (NULL, state);
dialog_set_sec_button_sensitivity (NULL, state);
/* dialog */
wbc_gtk_attach_guru (state->wbcg, state->dialog);
g_signal_connect_swapped (G_OBJECT (state->dialog),
"destroy",
G_CALLBACK (cb_dialog_solver_destroy),
state);
g_object_set_data_full (G_OBJECT (state->dialog),
"state", state,
(GDestroyNotify)unref_state);
return FALSE;
}
gboolean
gnm_dao_get_data (GnmDao *gdao, data_analysis_output_t **dao)
{
gboolean dao_ready = FALSE;
int grp_val;
g_return_val_if_fail (gdao != NULL, FALSE);
grp_val = gnm_gui_group_value (gdao->gui, dao_group);
dao_ready = ((grp_val != 2) ||
gnm_expr_entry_is_cell_ref
(GNM_EXPR_ENTRY (gdao->output_entry),
wb_control_cur_sheet (GNM_WBC (gdao->wbcg)),
TRUE));
if (dao_ready && NULL != dao) {
GtkWidget *button;
GnmValue *output_range = NULL;
switch (grp_val) {
case 0:
default:
*dao = dao_init_new_sheet (*dao);
break;
case 1:
*dao = dao_init (*dao, NewWorkbookOutput);
break;
case 2:
output_range = gnm_expr_entry_parse_as_value
(GNM_EXPR_ENTRY (gdao->output_entry),
wb_control_cur_sheet (GNM_WBC
(gdao->wbcg)));
*dao = dao_init (*dao, RangeOutput);
dao_load_from_value (*dao, output_range);
value_release (output_range);
break;
case 3:
(*dao) = dao_init ((*dao), InPlaceOutput);
/* It is the callers responsibility to fill the */
/* dao with the appropriate range. */
break;
}
button = go_gtk_builder_get_widget (gdao->gui, "autofit_button");
(*dao)->autofit_flag = gtk_toggle_button_get_active (
GTK_TOGGLE_BUTTON (button));
(*dao)->clear_outputrange = gtk_toggle_button_get_active (
GTK_TOGGLE_BUTTON (gdao->clear_outputrange_button));
(*dao)->retain_format = gtk_toggle_button_get_active (
GTK_TOGGLE_BUTTON (gdao->retain_format_button));
(*dao)->retain_comments = gtk_toggle_button_get_active (
GTK_TOGGLE_BUTTON (gdao->retain_comments_button));
(*dao)->put_formulas
= (gtk_combo_box_get_active
(GTK_COMBO_BOX (gdao->put_menu))
!= 0);
}
return dao_ready;
}
