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