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