/**
* 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;
}
/**
* 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;
}
static void
extract_settings (SolverState *state)
{
GnmSolverParameters *param = state->sheet->solver_parameters;
GtkTreeIter iter;
GnmValue *target_range;
GnmValue *input_range;
GnmSolverFactory *factory = NULL;
target_range = gnm_expr_entry_parse_as_value (state->target_entry,
state->sheet);
input_range = gnm_expr_entry_parse_as_value (state->change_cell_entry,
state->sheet);
gnm_solver_param_set_input (param, input_range);
gnm_solver_param_set_target (param,
target_range
? &target_range->v_range.cell.a
: NULL);
param->problem_type =
gnm_gui_group_value (state->gui, problem_type_group);
param->options.model_type =
gnm_gui_group_value (state->gui, model_type_group);
if (gtk_combo_box_get_active_iter (state->algorithm_combo, &iter)) {
gtk_tree_model_get (gtk_combo_box_get_model (state->algorithm_combo),
&iter, 1, &factory, -1);
gnm_solver_param_set_algorithm (param, factory);
} else
gnm_solver_param_set_algorithm (param, NULL);
param->options.max_iter = gtk_spin_button_get_value
(GTK_SPIN_BUTTON (state->max_iter_entry));
param->options.max_time_sec = gtk_spin_button_get_value
(GTK_SPIN_BUTTON (state->max_time_entry));
param->options.gradient_order = gtk_spin_button_get_value
(GTK_SPIN_BUTTON (state->gradient_order_entry));
GET_BOOL_ENTRY ("autoscale_button", options.automatic_scaling);
GET_BOOL_ENTRY ("non_neg_button", options.assume_non_negative);
GET_BOOL_ENTRY ("all_int_button", options.assume_discrete);
GET_BOOL_ENTRY ("program", options.program_report);
GET_BOOL_ENTRY ("sensitivity", options.sensitivity_report);
g_free (param->options.scenario_name);
param->options.scenario_name = g_strdup
(gtk_entry_get_text (GTK_ENTRY (state->scenario_name_entry)));
GET_BOOL_ENTRY ("optimal_scenario", options.add_scenario);
value_release (target_range);
}
/**
* 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);
}
/**
* 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
constraint_fill (GnmSolverConstraint *c, SolverState *state)
{
Sheet *sheet = state->sheet;
c->type = gtk_combo_box_get_active (state->type_combo);
gnm_solver_constraint_set_lhs
(c,
gnm_expr_entry_parse_as_value (state->lhs.entry, sheet));
gnm_solver_constraint_set_rhs
(c,
gnm_solver_constraint_has_rhs (c)
? gnm_expr_entry_parse_as_value (state->rhs.entry, sheet)
: NULL);
}
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);
}
/**
* 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;
}
/**
* parse_output:
*
* @state:
* @dao:
*
* fill dao with information from the standard output section of a dialog
*/
data_analysis_output_t *
parse_output (GenericToolState *state, data_analysis_output_t *dao)
{
data_analysis_output_t *this_dao = dao;
gnm_dao_get_data (GNM_DAO (state->gdao), &this_dao);
if (this_dao->type == InPlaceOutput) {
GnmValue *output_range
= gnm_expr_entry_parse_as_value (
state->input_entry, state->sheet);
dao_load_from_value (this_dao, output_range);
value_release (output_range);
}
return this_dao;
}
/**
* 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);
}
static GnmCell *
single_cell (Sheet *sheet, GnmExprEntry *gee)
{
int col, row;
gboolean issingle;
GnmValue *v = gnm_expr_entry_parse_as_value (gee, sheet);
if (!v) return NULL;
col = v->v_range.cell.a.col;
row = v->v_range.cell.a.row;
issingle = (col == v->v_range.cell.b.col && row == v->v_range.cell.b.row);
value_release (v);
if (issingle)
return sheet_cell_fetch (sheet, col, row);
else
return NULL;
}
/**
* 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_merge_merge_clicked (G_GNUC_UNUSED GtkWidget *ignore,
MergeState *state)
{
GtkTreeIter this_iter;
gint n = 0;
char *data_string = NULL, *field_string = NULL;
GSList *data_list = NULL, *field_list = NULL;
GnmValue *v_zone;
gint field_problems = 0;
gint min_length = gnm_sheet_get_max_rows (state->sheet);
gint max_length = 0;
v_zone = gnm_expr_entry_parse_as_value (state->zone, state->sheet);
g_return_if_fail (v_zone != NULL);
while (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (state->model),
&this_iter, NULL, n)) {
GnmValue *v_data, *v_field;
gtk_tree_model_get (GTK_TREE_MODEL (state->model), &this_iter,
DATA_RANGE, &data_string,
FIELD_LOCATION, &field_string,
-1);
v_data = value_new_cellrange_str (state->sheet, data_string);
v_field = value_new_cellrange_str (state->sheet, field_string);
g_free (data_string);
g_free (field_string);
g_return_if_fail (v_data != NULL && v_field != NULL);
if (!global_range_contained (state->sheet, v_field, v_zone))
field_problems++;
data_list = g_slist_prepend (data_list, v_data);
field_list = g_slist_prepend (field_list, v_field);
n++;
}
if (field_problems > 0) {
char *text;
if (field_problems == 1)
text = g_strdup (_("One field is not part of the merge zone!"));
else
text = g_strdup_printf (_("%i fields are not part of the merge zone!"),
field_problems);
go_gtk_notice_nonmodal_dialog ((GtkWindow *) state->dialog,
&(state->warning_dialog),
GTK_MESSAGE_ERROR,
"%s", text);
g_free (text);
value_release (v_zone);
range_list_destroy (data_list);
range_list_destroy (field_list);
return;
}
g_slist_foreach (data_list, cb_merge_find_shortest_column, &min_length);
g_slist_foreach (data_list, cb_merge_find_longest_column, &max_length);
if (min_length < max_length) {
char *text = g_strdup_printf (_("The data columns range in length from "
"%i to %i. Shall we trim the lengths to "
"%i and proceed?"), min_length, max_length,
min_length);
if (go_gtk_query_yes_no (GTK_WINDOW (state->dialog), TRUE,
"%s", text)) {
g_slist_foreach (data_list, cb_merge_trim_data, &min_length);
g_free (text);
} else {
g_free (text);
value_release (v_zone);
range_list_destroy (data_list);
range_list_destroy (field_list);
return;
}
}
if (!cmd_merge_data (WORKBOOK_CONTROL (state->wbcg), state->sheet,
v_zone, field_list, data_list))
gtk_widget_destroy (state->dialog);
}
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;
}
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), "");
}
/**
* 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;
}
/**
* 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;
}
/**
* cb_dialog_apply_clicked:
* @button:
* @state:
*
* Close (destroy) the dialog
**/
static void
cb_dialog_apply_clicked (G_GNUC_UNUSED GtkWidget *button,
GoalSeekState *state)
{
char *status_str;
GoalSeekStatus status;
GnmValue *target;
GnmRangeRef const *r;
GOFormat *format;
if (state->warning_dialog != NULL)
gtk_widget_destroy (state->warning_dialog);
/* set up source */
target = gnm_expr_entry_parse_as_value (state->set_cell_entry,
state->sheet);
if (target == NULL) {
go_gtk_notice_nonmodal_dialog (GTK_WINDOW(state->dialog),
&(state->warning_dialog),
GTK_MESSAGE_ERROR,
_("You should introduce a valid cell "
"name in 'Set Cell:'!"));
gnm_expr_entry_grab_focus (state->set_cell_entry, TRUE);
return;
}
r = &target->v_range.cell;
state->set_cell = sheet_cell_get (r->a.sheet, r->a.col, r->a.row);
value_release (target);
if (state->set_cell == NULL || !gnm_cell_has_expr (state->set_cell)) {
go_gtk_notice_nonmodal_dialog (GTK_WINDOW(state->dialog),
&(state->warning_dialog),
GTK_MESSAGE_ERROR,
_("The cell named in 'Set Cell:' "
"must contain a formula!"));
gnm_expr_entry_grab_focus (state->set_cell_entry, TRUE);
return;
}
/* set up source */
target = gnm_expr_entry_parse_as_value (state->change_cell_entry,
state->sheet);
if (target == NULL) {
go_gtk_notice_nonmodal_dialog (GTK_WINDOW(state->dialog),
&(state->warning_dialog),
GTK_MESSAGE_ERROR,
_("You should introduce a valid cell "
"name in 'By Changing Cell:'!"));
gnm_expr_entry_grab_focus (state->change_cell_entry, TRUE);
return;
}
r = &target->v_range.cell;
state->change_cell = sheet_cell_fetch (r->a.sheet, r->a.col, r->a.row);
value_release (target);
if (gnm_cell_has_expr (state->change_cell)) {
go_gtk_notice_nonmodal_dialog (GTK_WINDOW(state->dialog),
&(state->warning_dialog),
GTK_MESSAGE_ERROR,
_("The cell named in 'By changing cell' "
"must not contain a formula."));
gnm_expr_entry_grab_focus (state->change_cell_entry, TRUE);
return;
}
format = gnm_style_get_format (gnm_cell_get_style (state->set_cell));
if (entry_to_float_with_format (GTK_ENTRY(state->to_value_entry),
&state->target_value, TRUE, format)){
go_gtk_notice_nonmodal_dialog (GTK_WINDOW(state->dialog),
&(state->warning_dialog),
GTK_MESSAGE_ERROR,
_("The value given in 'To Value:' "
"is not valid."));
focus_on_entry (GTK_ENTRY(state->to_value_entry));
return;
}
format = gnm_style_get_format (gnm_cell_get_style (state->change_cell));
if (entry_to_float_with_format (GTK_ENTRY(state->at_least_entry),
&state->xmin, TRUE, format)) {
state->xmin = -max_range_val;
gtk_entry_set_text (GTK_ENTRY (state->at_least_entry), "");
}
if (entry_to_float_with_format (GTK_ENTRY(state->at_most_entry), &state->xmax,
TRUE, format)) {
state->xmax = +max_range_val;
gtk_entry_set_text (GTK_ENTRY (state->at_most_entry), "");
}
if ((state->old_cell != NULL) && (state->old_value != NULL)) {
sheet_cell_set_value (state->old_cell, state->old_value);
workbook_recalc (state->wb);
state->old_value = NULL;
}
state->old_cell = state->change_cell;
state->old_value = value_dup (state->change_cell->value);
status = gnumeric_goal_seek (state);
switch (status) {
case GOAL_SEEK_OK: {
const char *actual_str;
const char *solution_str;
GOFormat *format = go_format_general ();
GnmValue *error_value = value_new_float (state->target_value -
value_get_as_float (state->set_cell->value));
char *target_str = format_value (format, error_value, NULL, -1,
workbook_date_conv (state->wb));
gtk_label_set_text (GTK_LABEL (state->target_value_label), target_str);
g_free (target_str);
value_release (error_value);
status_str =
g_strdup_printf (_("Goal seeking with cell %s found a solution."),
cell_name (state->set_cell));
gtk_label_set_text (GTK_LABEL (state->result_label), status_str);
g_free (status_str);
/* FIXME? Do a format? */
actual_str = state->set_cell->value
? value_peek_string (state->set_cell->value)
: "";
gtk_label_set_text (GTK_LABEL (state->current_value_label), actual_str);
solution_str = state->change_cell->value
? value_peek_string (state->change_cell->value)
: "";
gtk_label_set_text (GTK_LABEL (state->solution_label), solution_str);
break;
}
default:
status_str =
g_strdup_printf (_("Goal seeking with cell %s did not find a solution."),
cell_name (state->set_cell));
gtk_label_set_text (GTK_LABEL (state->result_label), status_str);
g_free (status_str);
gtk_label_set_text (GTK_LABEL (state->current_value_label), "");
gtk_label_set_text (GTK_LABEL (state->solution_label), "");
gtk_label_set_text (GTK_LABEL (state->target_value_label), "");
break;
}
state->cancelled = FALSE;
gtk_widget_show (state->result_table);
return;
}
