/** * go_gtk_url_is_writeable: * @parent : #GtkWindow * @uri : * @overwrite_by_default : * * Check if it makes sense to try saving. * If it's an existing file and writable for us, ask if we want to overwrite. * We check for other problems, but if we miss any, the saver will report. * So it doesn't have to be bulletproof. * * FIXME: The message boxes should really be children of the file selector, * not the workbook. **/ gboolean go_gtk_url_is_writeable (GtkWindow *parent, char const *uri, gboolean overwrite_by_default) { gboolean result = TRUE; char *filename; if (uri == NULL || uri[0] == '\0') result = FALSE; filename = go_filename_from_uri (uri); if (!filename) return TRUE; /* Just assume writable. */ if (G_IS_DIR_SEPARATOR (filename [strlen (filename) - 1]) || g_file_test (filename, G_FILE_TEST_IS_DIR)) { go_gtk_notice_dialog (parent, GTK_MESSAGE_ERROR, _("%s\nis a directory name"), uri); result = FALSE; } else if (go_file_access (uri, W_OK) != 0 && errno != ENOENT) { go_gtk_notice_dialog (parent, GTK_MESSAGE_ERROR, _("You do not have permission to save to\n%s"), uri); result = FALSE; } else if (g_file_test (filename, G_FILE_TEST_EXISTS)) { char *dirname = go_dirname_from_uri (uri, TRUE); char *basename = go_basename_from_uri (uri); char *msg = g_markup_printf_escaped ( _("A file called <i>%s</i> already exists in %s.\n\n" "Do you want to save over it?"), basename, dirname); GtkWidget *dialog = gtk_message_dialog_new_with_markup (parent, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK_CANCEL, msg); gtk_dialog_set_default_response (GTK_DIALOG (dialog), overwrite_by_default ? GTK_RESPONSE_OK : GTK_RESPONSE_CANCEL); result = GTK_RESPONSE_OK == go_gtk_dialog_run (GTK_DIALOG (dialog), parent); g_free (dirname); g_free (basename); g_free (msg); } g_free (filename); return result; }
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); }
void dialog_goto_cell (WBCGtk *wbcg) { GotoState* state; GtkBuilder *gui; g_return_if_fail (wbcg != NULL); if (gnumeric_dialog_raise_if_exists (wbcg, GOTO_KEY)) return; gui = gnm_gtk_builder_new ("goto.ui", NULL, GO_CMD_CONTEXT (wbcg)); if (gui == NULL) return; state = g_new (GotoState, 1); state->wbcg = wbcg; state->wb = wb_control_get_workbook (WORKBOOK_CONTROL (wbcg)); state->gui = gui; state->dialog = go_gtk_builder_get_widget (state->gui, "goto_dialog"); if (dialog_goto_init (state)) { go_gtk_notice_dialog (wbcg_toplevel (wbcg), GTK_MESSAGE_ERROR, _("Could not create the goto dialog.")); g_free (state); return; } gnumeric_keyed_dialog (state->wbcg, GTK_WINDOW (state->dialog), GOTO_KEY); gtk_widget_show_all (state->dialog); }
/** * dialog_goal_seek: * @wbcg: * @sheet: * * Create the dialog (guru). * **/ void dialog_goal_seek (WBCGtk *wbcg, Sheet *sheet) { GoalSeekState *state; GladeXML *gui; g_return_if_fail (IS_SHEET (sheet)); /* Testing hook. */ if (wbcg == NULL) { GnmRangeRef *range = g_object_get_data (G_OBJECT (sheet), "ssconvert-goal-seek"); if (range) { Sheet *start_sheet, *end_sheet; GnmEvalPos ep; GnmRange r; gnm_rangeref_normalize (range, eval_pos_init_sheet (&ep, sheet), &start_sheet, &end_sheet, &r); g_return_if_fail (start_sheet == sheet); dialog_goal_seek_test (sheet, &r); return; } } g_return_if_fail (wbcg != NULL); /* Only pop up one copy per workbook */ if (gnumeric_dialog_raise_if_exists (wbcg, GOALSEEK_KEY)) return; gui = gnm_glade_xml_new (GO_CMD_CONTEXT (wbcg), "goalseek.glade", NULL, NULL); if (gui == NULL) return; state = g_new (GoalSeekState, 1); state->wbcg = wbcg; state->wb = wb_control_get_workbook (WORKBOOK_CONTROL (wbcg)); state->sheet = sheet; state->gui = gui; state->warning_dialog = NULL; state->cancelled = TRUE; if (dialog_init (state)) { go_gtk_notice_dialog (wbcg_toplevel (wbcg), GTK_MESSAGE_ERROR, _("Could not create the Goal-Seek dialog.")); g_free (state); return; } gnumeric_keyed_dialog (state->wbcg, GTK_WINDOW (state->dialog), GOALSEEK_KEY); gtk_widget_show (state->dialog); }
/** * dialog_solver: * @wbcg: * @sheet: * * Create the dialog (guru). * **/ void dialog_solver (WBCGtk *wbcg, Sheet *sheet) { SolverState *state; GnmSolverParameters *old_params = sheet->solver_parameters; gboolean got_it; int pass; /* Only pop up one copy per workbook */ if (gnm_dialog_raise_if_exists (wbcg, SOLVER_KEY)) return; /* * First time around, pick a functional algorithm preferably one we * can determine is functional without asking the user anything. */ got_it = gnm_solver_factory_functional (old_params->options.algorithm, NULL); for (pass = 1; !got_it && pass <= 2; pass++) { GSList *l; WBCGtk *wbcg2 = pass == 2 ? wbcg : NULL; for (l = gnm_solver_db_get (); l; l = l->next) { GnmSolverFactory *factory = l->data; if (old_params->options.model_type != factory->type) continue; if (gnm_solver_factory_functional (factory, wbcg2)) { got_it = TRUE; gnm_solver_param_set_algorithm (old_params, factory); break; } } } state = g_new0 (SolverState, 1); state->ref_count = 1; state->wbcg = wbcg; state->sheet = sheet; state->warning_dialog = NULL; state->orig_params = gnm_solver_param_dup (sheet->solver_parameters, sheet); if (dialog_init (state)) { go_gtk_notice_dialog (wbcg_toplevel (wbcg), GTK_MESSAGE_ERROR, _("Could not create the Solver dialog.")); unref_state (state); return; } gnm_dialog_setup_destroy_handlers (GTK_DIALOG (state->dialog), wbcg, GNM_DIALOG_DESTROY_SHEET_REMOVED); gnm_keyed_dialog (state->wbcg, GTK_WINDOW (state->dialog), SOLVER_KEY); gtk_widget_show (state->dialog); }
static void hello_message (GnmAction const *action, WorkbookControl *wbc) { char *msg = g_strdup_printf ( _("This is message from the \"%s\" plugin."), go_plugin_get_name (uihello_plugin)); go_gtk_notice_dialog (wbcg_toplevel (WBC_GTK (wbc)), GTK_MESSAGE_INFO, "%s", msg); g_free (msg); }
static void cb_col_check_clicked (GtkToggleButton *togglebutton, gpointer _i) { int i = GPOINTER_TO_INT (_i); StfDialogData *pagedata = g_object_get_data (G_OBJECT (togglebutton), "pagedata"); gboolean active = gtk_toggle_button_get_active (togglebutton); GtkCellRenderer *renderer; GtkTreeViewColumn* column; GtkWidget *check_autofit; g_return_if_fail (i < pagedata->format.col_import_array_len); if (pagedata->format.col_import_array[i] == active) return; renderer = stf_preview_get_cell_renderer (pagedata->format.renderdata, i); g_object_set (G_OBJECT (renderer), "strikethrough", !active, NULL); gtk_widget_queue_draw (GTK_WIDGET (pagedata->format.renderdata->tree_view)); if (!active) { pagedata->format.col_import_array[i] = FALSE; pagedata->format.col_import_count--; format_page_update_column_selection (pagedata); } else { if (pagedata->format.col_import_count < GNM_MAX_COLS) { pagedata->format.col_import_array[i] = TRUE; pagedata->format.col_import_count++; format_page_update_column_selection (pagedata); } else { char *msg = g_strdup_printf( ngettext("A maximum of %d column can be imported.", "A maximum of %d columns can be imported.", GNM_MAX_COLS), GNM_MAX_COLS); gtk_toggle_button_set_active (togglebutton, FALSE); go_gtk_notice_dialog (GTK_WINDOW (pagedata->dialog), GTK_MESSAGE_WARNING, "%s", msg); g_free (msg); } } column = stf_preview_get_column (pagedata->format.renderdata, i); check_autofit = g_object_get_data (G_OBJECT (column), "checkbox-autofit"); gtk_widget_set_sensitive (check_autofit, active); return; }
void dialog_data_table (WBCGtk *wbcg) { GnmDialogDataTable *state; GnmRange const *r; GnmRange input_range; SheetView *sv; Sheet *sheet; g_return_if_fail (wbcg != NULL); if (wbc_gtk_get_guru (wbcg) || gnm_dialog_raise_if_exists (wbcg, DIALOG_DATA_TABLE_KEY)) return; sv = wb_control_cur_sheet_view (GNM_WBC (wbcg)); r = selection_first_range (sv, GO_CMD_CONTEXT (wbcg), _("Create Data Table")); if (NULL == r) return; if (range_width (r) <= 1 || range_height (r) <= 1) { GError *msg = g_error_new (go_error_invalid(), 0, _("The selection must have more than 1 column and row to create a Data Table.")); go_cmd_context_error (GO_CMD_CONTEXT (wbcg), msg); g_error_free (msg); return; } input_range = *r; input_range.start.col++; input_range.start.row++; sheet = sv_sheet (sv); if (sheet_range_splits_region (sheet, &input_range, NULL, GO_CMD_CONTEXT (wbcg), _("Data Table"))) return; if (cmd_cell_range_is_locked_effective (sheet, &input_range, GNM_WBC (wbcg), _("Data Table"))) return; state = g_new0 (GnmDialogDataTable, 1); state->wbcg = wbcg; state->sheet = sheet; state->input_range = input_range; if (data_table_init (state, wbcg)) { go_gtk_notice_dialog (wbcg_toplevel (wbcg), GTK_MESSAGE_ERROR, _("Could not create the Data Table definition dialog.")); g_free (state); } }
/** * cb_dialog_solve_clicked: * @button: * @state: * * **/ static void cb_dialog_solve_clicked (G_GNUC_UNUSED GtkWidget *button, SolverState *state) { GnmSolverResult *res; GnmSolverParameters *param = state->sheet->solver_parameters; GError *err = NULL; if (state->warning_dialog != NULL) { gtk_widget_destroy (state->warning_dialog); state->warning_dialog = NULL; } extract_settings (state); if (!gnm_solver_param_valid (param, &err)) { GtkWidget *top = gtk_widget_get_toplevel (state->dialog); go_gtk_notice_dialog (GTK_WINDOW (top), GTK_MESSAGE_ERROR, "%s", err->message); goto out; } check_for_changed_options (state); res = run_solver (state, param); gnm_app_recalc (); if (res != NULL) { if ((res->quality == GNM_SOLVER_RESULT_OPTIMAL || res->quality == GNM_SOLVER_RESULT_FEASIBLE) && param->options.add_scenario) solver_add_scenario (state, res, param->options.scenario_name); g_object_unref (res); } else if (err) { go_gtk_notice_nonmodal_dialog (GTK_WINDOW (state->dialog), &(state->warning_dialog), GTK_MESSAGE_ERROR, "%s", err->message); } out: if (err) g_error_free (err); }
static void stf_warning (GOIOContext *context, char const *msg) { /* * Using go_cmd_context_error_import will destroy the * successfully imported portion. We ought to have a * way to issue a warning. */ if (GNM_IS_WBC_GTK (context->impl)) go_gtk_notice_dialog (wbcg_toplevel (WBC_GTK (context->impl)), GTK_MESSAGE_WARNING, "%s", msg); else g_warning ("%s", msg); }
static void view_data_sources (GnmAction const *action, WorkbookControl *wbc) { char *argv[2]; argv[0] = (char *) "gnome-database-properties-4.0"; argv[1] = NULL; if (!g_spawn_async (NULL, argv, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL, NULL, NULL)) { char *msg = g_strdup_printf ( _("Could not run GNOME database configuration tool ('%s')"), argv[0]); go_gtk_notice_dialog (wbcg_toplevel (WBC_GTK (wbc)), GTK_MESSAGE_INFO, msg); g_free (msg); } }
void dialog_so_list (WBCGtk *wbcg, GObject *so) { GnmDialogSOList *state; g_return_if_fail (wbcg != NULL); if (wbc_gtk_get_guru (wbcg) || gnm_dialog_raise_if_exists (wbcg, DIALOG_SO_LIST_KEY)) return; state = g_new0 (GnmDialogSOList, 1); if (so_list_init (state, wbcg, GNM_SO (so))) { go_gtk_notice_dialog (wbcg_toplevel (wbcg), GTK_MESSAGE_ERROR, _("Could not create the List Property dialog.")); g_free (state); } }
static GnmSolverResult * run_solver (SolverState *state, GnmSolverParameters *param) { GError *err = NULL; gboolean ok; GnmSheetRange sr; GOUndo *undo = NULL; GnmSolver *sol = NULL; GnmValue const *vinput; GtkWindow *top = GTK_WINDOW (gtk_widget_get_toplevel (state->dialog)); GnmSolverResult *res = NULL; state->ref_count++; sol = gnm_solver_factory_functional (param->options.algorithm, state->wbcg) ? gnm_solver_factory_create (param->options.algorithm, param) : NULL; if (!sol) { go_gtk_notice_dialog (top, GTK_MESSAGE_ERROR, _("The chosen solver is not functional.")); goto fail; } gtk_notebook_set_current_page (GTK_NOTEBOOK (state->notebook), -1); state->run.solver = sol; vinput = gnm_solver_param_get_input (param); gnm_sheet_range_from_value (&sr, vinput); if (!sr.sheet) sr.sheet = param->sheet; undo = clipboard_copy_range_undo (sr.sheet, &sr.range); g_signal_connect_swapped (G_OBJECT (sol), "notify::status", G_CALLBACK (cb_notify_status), state); g_signal_connect_swapped (G_OBJECT (sol), "notify::reason", G_CALLBACK (cb_notify_status), state); cb_notify_status (state); g_signal_connect_swapped (G_OBJECT (sol), "notify::result", G_CALLBACK (cb_notify_result), state); cb_notify_result (state); state->run.timer_source = g_timeout_add_seconds (1, (GSourceFunc)cb_timer_tick, state); cb_timer_tick (state); /* ---------------------------------------- */ ok = gnm_solver_start (sol, GNM_WBC (state->wbcg), &err); if (ok) { state->run.in_main++; go_cmd_context_set_sensitive (GO_CMD_CONTEXT (state->wbcg), FALSE); gtk_main (); go_cmd_context_set_sensitive (GO_CMD_CONTEXT (state->wbcg), TRUE); state->run.in_main--; ok = gnm_solver_has_solution (sol); } else if (err) { gnm_solver_set_reason (sol, err->message); } g_clear_error (&err); remove_objective_value_source (state); remove_timer_source (state); /* ---------------------------------------- */ if (ok) { GOUndo *redo; gnm_solver_store_result (sol); redo = clipboard_copy_range_undo (sr.sheet, &sr.range); if (param->options.program_report || param->options.sensitivity_report) { Workbook *wb = param->sheet->workbook; GOUndo *undo_report, *redo_report; undo_report = go_undo_binary_new (wb, workbook_sheet_state_new (wb), (GOUndoBinaryFunc)workbook_sheet_state_restore, NULL, (GFreeFunc)workbook_sheet_state_free); undo = go_undo_combine (undo, undo_report); create_report (sol, state); redo_report = go_undo_binary_new (wb, workbook_sheet_state_new (wb), (GOUndoBinaryFunc)workbook_sheet_state_restore, NULL, (GFreeFunc)workbook_sheet_state_free); redo = go_undo_combine (redo, redo_report); } cmd_generic (GNM_WBC (state->wbcg), _("Running solver"), undo, redo); res = g_object_ref (sol->result); undo = redo = NULL; } fail: if (undo) g_object_unref (undo); if (state->run.solver) { g_object_unref (state->run.solver); state->run.solver = NULL; } unref_state (state); return res; }
void dialog_scenarios (WBCGtk *wbcg) { ScenariosState *state; WorkbookControl *wbc; Sheet *sheet; GtkWidget *w; GtkTreeSelection *select; char const *error_str = _("Could not create the Scenarios dialog."); g_return_if_fail (wbcg != NULL); wbc = WORKBOOK_CONTROL (wbcg); sheet = wb_control_cur_sheet (wbc); state = g_new (ScenariosState, 1); state->new_report_sheets = NULL; state->current = NULL; state->undo = NULL; state->base.wb = wb_control_get_workbook (wbc); if (dialog_tool_init (&state->base, wbcg, sheet, GNUMERIC_HELP_LINK_SCENARIOS_VIEW, "scenario-manager.ui", "Scenarios", error_str, "Scenarios", G_CALLBACK (scenarios_ok_clicked_cb), G_CALLBACK (scenarios_cancel_clicked_cb), G_CALLBACK (scenarios_update_sensitivity_cb), 0)) goto error_out; if (init_scenario_buttons (state)) goto error_out; state->scenarios_treeview = go_gtk_builder_get_widget (state->base.gui, "scenarios_treeview"); if (state->scenarios_treeview == NULL) goto error_out; w = go_gtk_builder_get_widget (state->base.gui, "changing_cells_entry"); if (w == NULL) goto error_out; gtk_widget_set_sensitive (w, FALSE); w = go_gtk_builder_get_widget (state->base.gui, "comment_view"); if (w == NULL) goto error_out; gtk_widget_set_sensitive (w, FALSE); if (state->base.sheet->scenarios == NULL) gtk_widget_set_sensitive (state->summary_button, FALSE); update_scenarios_treeview (state->scenarios_treeview, sheet->scenarios); select = gtk_tree_view_get_selection (GTK_TREE_VIEW (state->scenarios_treeview)); g_signal_connect (select, "changed", G_CALLBACK (cb_selection_changed), state); scenarios_update_sensitivity_cb (NULL, state); gtk_widget_show (state->base.dialog); return; error_out: go_gtk_notice_dialog (wbcg_toplevel (wbcg), GTK_MESSAGE_ERROR, "%s", error_str); g_free (state); return; }
void dialog_autosave (WBCGtk *wbcg) { GtkBuilder *gui; autosave_t *state; int secs; gboolean prompt; g_return_if_fail (wbcg != NULL); if (gnm_dialog_raise_if_exists (wbcg, AUTOSAVE_KEY)) return; gui = gnm_gtk_builder_load ("autosave.ui", NULL, GO_CMD_CONTEXT (wbcg)); if (gui == NULL) return; g_object_get (wbcg, "autosave-time", &secs, "autosave-prompt", &prompt, NULL); state = g_new (autosave_t, 1); state->wbcg = wbcg; state->wb = wb_control_get_workbook (GNM_WBC (wbcg)); state->dialog = go_gtk_builder_get_widget (gui, "AutoSave"); state->minutes_entry = go_gtk_builder_get_widget (gui, "minutes"); state->prompt_cb = go_gtk_builder_get_widget (gui, "prompt_on_off"); state->autosave_on_off = go_gtk_builder_get_widget (gui, "autosave_on_off"); state->ok_button = go_gtk_builder_get_widget (gui, "button1"); state->cancel_button = go_gtk_builder_get_widget (gui, "button2"); if (!state->dialog || !state->minutes_entry || !state->prompt_cb || !state->autosave_on_off) { go_gtk_notice_dialog (wbcg_toplevel (wbcg), GTK_MESSAGE_ERROR, _("Could not create the autosave dialog.")); g_free (state); return; } float_to_entry (GTK_ENTRY (state->minutes_entry), secs / 60); gnm_editable_enters (GTK_WINDOW (state->dialog), state->minutes_entry); g_signal_connect (G_OBJECT (state->autosave_on_off), "toggled", G_CALLBACK (autosave_set_sensitivity), state); g_signal_connect (G_OBJECT (state->minutes_entry), "changed", G_CALLBACK (autosave_set_sensitivity), state); g_signal_connect (G_OBJECT (state->ok_button), "clicked", G_CALLBACK (cb_autosave_ok), state); g_signal_connect (G_OBJECT (state->cancel_button), "clicked", G_CALLBACK (cb_autosave_cancel), state); g_object_set_data_full (G_OBJECT (state->dialog), "state", state, (GDestroyNotify)g_free); gnm_init_help_button ( go_gtk_builder_get_widget (gui, "button3"), GNUMERIC_HELP_LINK_AUTOSAVE); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (state->autosave_on_off), secs > 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (state->prompt_cb), prompt); autosave_set_sensitivity (NULL, state); gnm_keyed_dialog (state->wbcg, GTK_WINDOW (state->dialog), AUTOSAVE_KEY); gtk_widget_show (state->dialog); g_object_unref (gui); }
static void go_help_display (CBHelpPaths const *paths) { #ifdef GOFFICE_WITH_GNOME gnome_help_display (paths->app, paths->link, NULL); #elif defined(G_OS_WIN32) static GHashTable* context_help_map = NULL; guint id; if (!context_help_map) { GsfInput *input; GsfInputTextline *textline; GError *err = NULL; gchar *mapfile = g_strconcat (paths->app, ".hhmap", NULL); gchar *path = g_build_filename (paths->data_dir, "doc", "C", mapfile, NULL); g_free (mapfile); if (!(input = gsf_input_stdio_new (path, &err)) || !(textline = (GsfInputTextline *) gsf_input_textline_new (input))) go_gtk_notice_dialog (NULL, GTK_MESSAGE_ERROR, "Cannot open '%s': %s", path, err ? err->message : "failed to create gsf-input-textline"); else { gchar *line, *topic; gulong id, i = 1; context_help_map = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL); while ((line = gsf_input_textline_utf8_gets (textline)) != NULL) { if (!(id = strtoul (line, &topic, 10))) { go_gtk_notice_dialog (NULL, GTK_MESSAGE_ERROR, "Invalid topic id at line %lu in %s: '%s'", i, path, line); continue; } for (; *topic == ' '; ++topic); g_hash_table_insert (context_help_map, g_strdup (topic), (gpointer)id); } g_object_unref (G_OBJECT (textline)); } if (input) g_object_unref (G_OBJECT (input)); g_free (path); } if (!(id = (guint) g_hash_table_lookup (context_help_map, paths->link))) go_gtk_notice_dialog (NULL, GTK_MESSAGE_ERROR, "Topic '%s' not found.", paths->link); else { gchar *chmfile = g_strconcat (paths->app, ".chm", NULL); gchar *path = g_build_filename (paths->data_dir, "doc", "C", chmfile, NULL); g_free (chmfile); if (!HtmlHelp (GetDesktopWindow (), path, HH_HELP_CONTEXT, id)) go_gtk_notice_dialog (NULL, GTK_MESSAGE_ERROR, "Failed to spawn HtmlHelp"); g_free (path); } #else go_gtk_notice_dialog (NULL, GTK_MESSAGE_ERROR, "TODO : launch help browser for %s", paths->link); #endif }
void dialog_delete_cells (WBCGtk *wbcg) { DeleteCellState *state; WorkbookControl *wbc = GNM_WBC (wbcg); SheetView *sv = wb_control_cur_sheet_view (wbc); Sheet *sheet = sv_sheet (sv); GnmRange const *sel; GtkBuilder *gui; GtkWidget *w; int cols, rows; g_return_if_fail (wbcg != NULL); if (!(sel = selection_first_range (sv, GO_CMD_CONTEXT (wbc), _("Delete")))) return; cols = sel->end.col - sel->start.col + 1; rows = sel->end.row - sel->start.row + 1; if (range_is_full (sel, sheet, FALSE)) { cmd_delete_cols (wbc, sheet, sel->start.col, cols); return; } if (range_is_full (sel, sheet, TRUE)) { cmd_delete_rows (wbc, sheet, sel->start.row, rows); return; } if (gnm_dialog_raise_if_exists (wbcg, DELETE_CELL_DIALOG_KEY)) return; gui = gnm_gtk_builder_load ("res:ui/delete-cells.ui", NULL, GO_CMD_CONTEXT (wbcg)); if (gui == NULL) return; state = g_new (DeleteCellState, 1); state->wbcg = wbcg; state->sel = sel; state->gui = gui; state->sheet = sv_sheet (sv); state->dialog = go_gtk_builder_get_widget (state->gui, "Delete_cells"); if (state->dialog == NULL) { go_gtk_notice_dialog (wbcg_toplevel (wbcg), GTK_MESSAGE_ERROR, _("Could not create the Delete Cell dialog.")); g_free (state); return ; } w = go_gtk_builder_get_widget (state->gui, "okbutton"); g_signal_connect_swapped (G_OBJECT (w), "clicked", G_CALLBACK (cb_delete_cell_ok_clicked), state); w = go_gtk_builder_get_widget (state->gui, "cancelbutton"); g_signal_connect (G_OBJECT (w), "clicked", G_CALLBACK (cb_delete_cell_cancel_clicked), state); gnm_dialog_setup_destroy_handlers (GTK_DIALOG (state->dialog), state->wbcg, GNM_DIALOG_DESTROY_CURRENT_SHEET_REMOVED); gnm_init_help_button ( go_gtk_builder_get_widget (state->gui, "helpbutton"), GNUMERIC_HELP_LINK_DELETE_CELLS); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (go_gtk_builder_get_widget (state->gui, cols < rows ? "radio_0" : "radio_1")), TRUE); wbc_gtk_attach_guru (state->wbcg, state->dialog); g_object_set_data_full (G_OBJECT (state->dialog), "state", state, (GDestroyNotify) cb_delete_cell_destroy); gnm_keyed_dialog (wbcg, GTK_WINDOW (state->dialog), DELETE_CELL_DIALOG_KEY); gtk_widget_show (state->dialog); }
static void cb_view_ok_clicked (G_GNUC_UNUSED GtkWidget *button, ViewState *state) { WBCGtk *wbcg = state->wbcg; WorkbookControl *wbc = WORKBOOK_CONTROL (wbcg); WorkbookControl *new_wbc; gboolean shared; GdkScreen *screen; GSList *buttons = gtk_radio_button_get_group (state->location_elsewhere); shared = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (go_gtk_builder_get_widget (state->gui, "view_shared"))); while (buttons) if (gtk_toggle_button_get_active (buttons->data)) break; else buttons = buttons->next; if (!buttons) { g_assert_not_reached (); return; } else if (buttons->data == state->location_elsewhere) { const char *name = gtk_entry_get_text (state->location_display_name); GdkDisplay *display; if (!name) return; /* Just ignore */ display = gdk_display_open (name); if (!display) { char *error_str = g_strdup_printf (_("Display \"%s\" could not be opened."), name); gtk_widget_destroy (state->dialog); go_gtk_notice_dialog (wbcg_toplevel (wbcg), GTK_MESSAGE_ERROR, "%s", error_str); g_free (error_str); return; } screen = gdk_display_get_default_screen (display); } else { screen = g_object_get_data (buttons->data, "screen"); } gtk_widget_destroy (state->dialog); new_wbc = wb_control_wrapper_new (wbc, shared ? wb_control_view (wbc) : NULL, wb_control_get_workbook (wbc), screen); if (IS_WBC_GTK (new_wbc)) { /* What else would it be? */ WBCGtk *new_wbcg = WBC_GTK (new_wbc); wbcg_copy_toolbar_visibility (new_wbcg, wbcg); _gnm_app_flag_windows_changed (); } }
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 cb_toggled_visible (G_GNUC_UNUSED GtkCellRendererToggle *cell, gchar *path_string, gpointer data) { SheetManager *state = data; GtkTreeModel *model = GTK_TREE_MODEL (state->model); GtkTreeIter iter; GtkTreePath *path = gtk_tree_path_new_from_string (path_string); gboolean is_visible; Sheet *this_sheet; WorkbookSheetState *old_state; WorkbookControl *wbc = GNM_WBC (state->wbcg); Workbook *wb = wb_control_get_workbook (wbc); int cnt; if (!gtk_tree_model_get_iter (model, &iter, path)) { g_warning ("Did not get a valid iterator"); gtk_tree_path_free (path); return; } gtk_tree_model_get (model, &iter, SHEET_VISIBLE, &is_visible, SHEET_POINTER, &this_sheet, -1); if (is_visible) { cnt = sheet_order_cnt_visible (state); if (cnt <= 1) { go_gtk_notice_dialog (GTK_WINDOW (state->dialog), GTK_MESSAGE_ERROR, _("At least one sheet must remain visible!")); gtk_tree_path_free (path); return; } gtk_list_store_set (GTK_LIST_STORE (model), &iter, SHEET_VISIBLE, FALSE, SHEET_VISIBLE_IMAGE, NULL, -1); } else { gtk_list_store_set (GTK_LIST_STORE (model), &iter, SHEET_VISIBLE, TRUE, SHEET_VISIBLE_IMAGE, state->image_visible, -1); } gtk_tree_path_free (path); old_state = workbook_sheet_state_new (wb); g_object_set (this_sheet, "visibility", !is_visible ? GNM_SHEET_VISIBILITY_VISIBLE : GNM_SHEET_VISIBILITY_HIDDEN, NULL); cmd_reorganize_sheets (wbc, old_state, this_sheet); update_undo (state, wbc); if (is_visible) populate_sheet_list (state); }
static void search_clicked (G_GNUC_UNUSED GtkWidget *widget, DialogState *dd) { GtkBuilder *gui = dd->gui; WBCGtk *wbcg = dd->wbcg; WorkbookControl *wbc = WORKBOOK_CONTROL (wbcg); GnmSearchReplace *sr; char *err; int i; GnmSearchReplaceScope scope; char *text; gboolean is_regexp, is_number; i = go_gtk_builder_group_value (gui, scope_group); scope = (i == -1) ? GNM_SRS_SHEET : (GnmSearchReplaceScope)i; i = go_gtk_builder_group_value (gui, search_type_group); is_regexp = (i == 1); is_number = (i == 2); text = gnm_search_normalize (gtk_entry_get_text (dd->gentry)); sr = g_object_new (GNM_SEARCH_REPLACE_TYPE, "sheet", wb_control_cur_sheet (wbc), "scope", scope, "range-text", gnm_expr_entry_get_text (dd->rangetext), "search-text", text, "is-regexp", is_regexp, "is-number", is_number, "ignore-case", is_checked (gui, "ignore_case"), "match-words", is_checked (gui, "match_words"), "search-strings", is_checked (gui, "search_string"), "search-other-values", is_checked (gui, "search_other"), "search-expressions", is_checked (gui, "search_expr"), "search-expression-results", is_checked (gui, "search_expr_results"), "search-comments", is_checked (gui, "search_comments"), "by-row", go_gtk_builder_group_value (gui, direction_group) == 0, NULL); g_free (text); err = gnm_search_replace_verify (sr, FALSE); if (err) { go_gtk_notice_dialog (GTK_WINDOW (dd->dialog), GTK_MESSAGE_ERROR, "%s", err); g_free (err); g_object_unref (sr); return; } else if (!sr->search_strings && !sr->search_other_values && !sr->search_expressions && !sr->search_expression_results && !sr->search_comments) { go_gtk_notice_dialog (GTK_WINDOW (dd->dialog), GTK_MESSAGE_ERROR, _("You must select some cell types to search.")); g_object_unref (sr); return; } if (is_checked (gui, "save-in-prefs")) dialog_search_save_in_prefs (dd); { GnumericLazyList *ll; GPtrArray *cells; /* Clear current table. */ gtk_tree_view_set_model (dd->matches_table, NULL); gnm_search_filter_matching_free (dd->matches); cells = gnm_search_collect_cells (sr); dd->matches = gnm_search_filter_matching (sr, cells); gnm_search_collect_cells_free (cells); ll = make_matches_model (dd, dd->matches->len); gtk_tree_view_set_model (dd->matches_table, GTK_TREE_MODEL (ll)); g_object_unref (ll); /* Set sensitivity of buttons. */ cursor_change (dd->matches_table, dd); } gtk_notebook_set_current_page (dd->notebook, dd->notebook_matches_page); gtk_widget_grab_focus (GTK_WIDGET (dd->matches_table)); g_object_unref (sr); }
/** * 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; }