static void
cb_dialog_goto_selection_changed (GtkTreeSelection *the_selection, GotoState *state)
{
GtkTreeIter iter;
GtkTreeModel *model;
Sheet *sheet;
GnmNamedExpr *name;
if (gtk_tree_selection_get_selected (the_selection, &model, &iter)) {
gtk_tree_model_get (model, &iter,
SHEET_POINTER, &sheet,
EXPRESSION, &name,
-1);
if (name && gnm_expr_top_is_rangeref (name->texpr)) {
GnmParsePos pp;
char *where_to;
if (NULL == sheet)
sheet = wb_control_cur_sheet ( WORKBOOK_CONTROL (state->wbcg));
parse_pos_init_sheet (&pp, sheet);
where_to = expr_name_as_string (name, &pp, gnm_conventions_default);
if (wb_control_parse_and_jump (WORKBOOK_CONTROL (state->wbcg), where_to))
gtk_entry_set_text (state->goto_text,
where_to);
g_free (where_to);
return;
}
if (sheet)
wb_view_sheet_focus (
wb_control_view (WORKBOOK_CONTROL (state->wbcg)), sheet);
}
}
/**
* 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
cb_dialog_goto_go_clicked (G_GNUC_UNUSED GtkWidget *button,
GotoState *state)
{
GnmEvalPos ep;
GnmRangeRef range;
gint cols = gtk_spin_button_get_value_as_int (state->spin_cols);
gint rows = gtk_spin_button_get_value_as_int (state->spin_rows);
GnmValue *val = dialog_goto_get_val (state);
Sheet *sheet = wb_control_cur_sheet (WORKBOOK_CONTROL (state->wbcg));
if (val == NULL)
return;
val->v_range.cell.b.row = val->v_range.cell.a.row + (rows - 1);
val->v_range.cell.b.col = val->v_range.cell.a.col + (cols - 1);
eval_pos_init_sheet (&ep, sheet);
gnm_cellref_make_abs (&range.a, &val->v_range.cell.a, &ep);
gnm_cellref_make_abs (&range.b, &val->v_range.cell.b, &ep);
value_release (val);
wb_control_jump (WORKBOOK_CONTROL (state->wbcg), sheet, &range);
#if 0
gnome_entry_append_history (state->goto_text, TRUE, text);
#endif
return;
}
/**
* 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;
}
static void
cb_dialog_so_size_apply_clicked (G_GNUC_UNUSED GtkWidget *button,
SOSizeState *state)
{
char const *name;
GOUndo *undo = NULL, *redo = NULL;
char const *undo_name = NULL;
int cnt = 0;
if (state->so_size_needs_restore || state->so_pos_needs_restore) {
char const *label = state->so_pos_needs_restore ?
_("Move Object") : _("Resize Object");
sheet_object_set_anchor (state->so, state->old_anchor);
if (!cmd_objects_move (WORKBOOK_CONTROL (state->wbcg),
g_slist_prepend (NULL, state->so),
g_slist_prepend
(NULL, sheet_object_anchor_dup
(state->active_anchor)),
FALSE, label))
dialog_so_size_load (state);
}
name = gtk_entry_get_text (state->nameentry);
if (name == NULL)
name = "";
if (strcmp (name, state->old_name) != 0) {
char *old_name, *new_name;
g_object_get (G_OBJECT (state->so), "name", &old_name, NULL);
undo = go_undo_combine (undo, set_params (state->so, old_name));
new_name = (*name == '\0') ? NULL : g_strdup (name);
redo = go_undo_combine (redo, set_params (state->so, new_name));
undo_name = _("Set Object Name");
cnt++;
}
if (state->so_print_check_changed) {
gboolean val = ((state->so->flags & SHEET_OBJECT_PRINT) != 0);
undo = go_undo_combine (undo, set_print_flag
(state->so, val));
redo = go_undo_combine (redo, set_print_flag
(state->so, !val));
undo_name = _("Set Object Print Property");
cnt++;
}
if (cnt > 0) {
if (cnt > 1)
undo_name = _("Set Object Properties");
state->so_name_changed = state->so_print_check_changed =
cmd_generic (WORKBOOK_CONTROL (state->wbcg),
undo_name, undo, redo);
}
dialog_so_size_button_sensitivity (state);
return;
}
static void
dialog_goto_load_selection (GotoState *state)
{
SheetView *sv = wb_control_cur_sheet_view
(WORKBOOK_CONTROL (state->wbcg));
GnmRange const *first = selection_first_range (sv, NULL, NULL);
if (first != NULL) {
gint rows = range_height (first);
gint cols = range_width (first);
GnmConventionsOut out;
GString *str = g_string_new (NULL);
GnmParsePos pp;
GnmRangeRef rr;
out.accum = str;
out.pp = parse_pos_init_sheet (&pp, sv->sheet);
out.convs = sheet_get_conventions (sv->sheet);
gnm_cellref_init (&rr.a, NULL, first->start.col,
first->start.row, TRUE);
gnm_cellref_init (&rr.b, NULL, first->start.col,
first->start.row, TRUE);
rangeref_as_string (&out, &rr);
gtk_entry_set_text (state->goto_text, str->str);
gtk_editable_select_region (GTK_EDITABLE (state->goto_text),
0, -1);
g_string_free (str, TRUE);
cb_dialog_goto_update_sensitivity (NULL, state);
gtk_spin_button_set_value (state->spin_rows, rows);
gtk_spin_button_set_value (state->spin_cols, cols);
} else
cb_dialog_goto_update_sensitivity (NULL, state);
}
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);
}
static void
cb_zoom_ok_clicked (G_GNUC_UNUSED GtkWidget *button, ZoomState *state)
{
GSList *sheets = NULL;
GList *l, *tmp;
l = gtk_tree_selection_get_selected_rows (state->sheet_list_selection, NULL);
for (tmp = l; tmp; tmp = tmp->next) {
GtkTreePath *path = tmp->data;
GtkTreeIter iter;
if (gtk_tree_model_get_iter (GTK_TREE_MODEL (state->sheet_list_model), &iter, path)) {
Sheet *this_sheet;
gtk_tree_model_get (GTK_TREE_MODEL (state->sheet_list_model),
&iter,
COL_SHEET_PTR, &this_sheet,
-1);
sheets = g_slist_prepend (sheets, this_sheet);
}
gtk_tree_path_free (path);
}
g_list_free (l);
if (sheets) {
WorkbookControl *wbc = WORKBOOK_CONTROL (state->wbcg);
double new_zoom = gtk_spin_button_get_value (state->zoom) / 100;
sheets = g_slist_reverse (sheets);
cmd_zoom (wbc, sheets, new_zoom);
}
gtk_widget_destroy (state->dialog);
}
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_fill_series (WBCGtk *wbcg)
{
FillSeriesState *state;
WorkbookControl *wbc = WORKBOOK_CONTROL (wbcg);
SheetView *sv = wb_control_cur_sheet_view (wbc);
g_return_if_fail (wbcg != NULL);
/* Only pop up one copy per workbook */
if (gnumeric_dialog_raise_if_exists (wbcg, FILL_SERIES_KEY)) {
return;
}
state = g_new (FillSeriesState, 1);
if (dialog_tool_init ((GenericToolState *)state, wbcg, sv_sheet (sv),
GNUMERIC_HELP_LINK_FILL_SERIES,
"fill-series.ui", "Fill_series",
_("Could not create the Fill Series dialog."),
FILL_SERIES_KEY,
G_CALLBACK (cb_fill_series_ok_clicked), NULL,
G_CALLBACK (cb_fill_series_update_sensitivity),
0))
return;
gnm_dao_set_put (GNM_DAO (state->base.gdao), FALSE, FALSE);
dialog_fill_series_tool_init (state);
gtk_widget_show (state->base.dialog);
return;
}
/**
* dialog_advanced_filter:
* @wbcg:
* @sheet:
*
* Show the dialog (guru).
*
**/
void
dialog_advanced_filter (WBCGtk *wbcg)
{
AdvancedFilterState *state;
WorkbookControl *wbc;
g_return_if_fail (wbcg != NULL);
wbc = WORKBOOK_CONTROL (wbcg);
/* Only pop up one copy per workbook */
if (gnumeric_dialog_raise_if_exists (wbcg, ADVANCED_FILTER_KEY))
return;
state = g_new (AdvancedFilterState, 1);
if (dialog_tool_init (state, wbcg, wb_control_cur_sheet (wbc),
GNUMERIC_HELP_LINK_ADVANCED_FILTER,
"advanced-filter.ui", "Filter",
_("Could not create the Advanced Filter dialog."),
ADVANCED_FILTER_KEY,
G_CALLBACK (advanced_filter_ok_clicked_cb), NULL,
G_CALLBACK (advanced_filter_update_sensitivity_cb),
0))
return;
gnm_dao_set_inplace (GNM_DAO (state->gdao), _("Filter _in-place"));
gnm_dao_set_put (GNM_DAO (state->gdao), FALSE, FALSE);
advanced_filter_update_sensitivity_cb (NULL, state);
tool_load_selection ((GenericToolState *)state, TRUE);
return;
}
/**
* scenarios_cancel_clicked_cb:
* @button:
* @state:
*
* Cancel clicked on the scenario manager tool.
**/
static void
scenarios_cancel_clicked_cb (G_GNUC_UNUSED GtkWidget *button,
ScenariosState *state)
{
GSList *cur;
WorkbookControl *wbc;
restore_old_values (state);
wbc = WORKBOOK_CONTROL (state->base.wbcg);
/* Remove report sheets created on this dialog session. */
for (cur = state->new_report_sheets; cur != NULL;
cur = cur->next) {
Sheet *sheet = cur->data;
/* Check that if the focus is on a deleted sheet. */
if (wb_control_cur_sheet (wbc) == sheet)
wb_control_sheet_focus (wbc, state->base.sheet);
/* Delete a report sheet. */
workbook_sheet_delete (sheet);
}
/* Recover the deleted scenarios. */
scenario_recover_all (state->base.sheet);
scenario_manager_free (state);
gtk_widget_destroy (state->base.dialog);
}
void
dialog_scenario_add (WBCGtk *wbcg)
{
ScenariosState *state;
WorkbookControl *wbc;
GtkWidget *comment_view;
char const *error_str = _("Could not create the Scenario Add dialog.");
GString *buf;
if (wbcg == NULL)
return;
wbc = WORKBOOK_CONTROL (wbcg);
/* Only pop up one copy per workbook */
if (gnumeric_dialog_raise_if_exists (wbcg, "ScenarioAdd"))
return;
state = g_new (ScenariosState, 1);
if (dialog_tool_init (&state->base, wbcg, wb_control_cur_sheet (wbc),
GNUMERIC_HELP_LINK_SCENARIOS_ADD,
"scenario-add.ui", "ScenarioAdd",
error_str,
"ScenarioAdd",
G_CALLBACK (scenario_add_ok_clicked_cb), NULL,
G_CALLBACK (scenario_add_update_sensitivity_cb),
GNM_EE_SHEET_OPTIONAL))
{
g_free (state);
return;
}
state->name_entry = go_gtk_builder_get_widget (state->base.gui, "name_entry");
if (state->name_entry == NULL)
return;
comment_view = go_gtk_builder_get_widget (state->base.gui, "comment_view");
if (comment_view == NULL)
return;
buf = g_string_new (NULL);
g_string_append_printf (buf, _("Created on "));
dao_append_date (buf);
gtk_text_buffer_set_text (gtk_text_view_get_buffer
(GTK_TEXT_VIEW (comment_view)), buf->str,
strlen (buf->str));
g_string_free (buf, FALSE);
state->base.gdao = NULL;
gnm_dialog_setup_destroy_handlers (GTK_DIALOG (state->base.dialog),
wbcg,
GNM_DIALOG_DESTROY_SHEET_REMOVED);
gnumeric_editable_enters (GTK_WINDOW (state->base.dialog),
GTK_WIDGET (state->name_entry));
scenario_add_update_sensitivity_cb (NULL, state);
tool_load_selection ((GenericToolState *)state, TRUE);
}
/**
* 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);
}
static void
workbook_control_init (GObject *obj)
{
WorkbookControl *wbc = WORKBOOK_CONTROL (obj);
wbc->clipboard_changed_signal = g_signal_connect (
gnm_app_get_app (),
"clipboard_modified",
G_CALLBACK (cb_wbc_clipboard_modified), wbc);
}
void
gnm_dao_load_range (GnmDao *gdao, GnmRange const *range)
{
g_return_if_fail (gdao != NULL);
gnm_expr_entry_load_from_range
(gdao->output_entry,
wb_control_cur_sheet (WORKBOOK_CONTROL (gdao->wbcg)),
range);
}
/**
* 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;
}
/*
* Main entry point for the Cell Sort dialog box
*/
void
dialog_cell_sort (WBCGtk *wbcg)
{
SortFlowState *state;
GtkBuilder *gui;
g_return_if_fail (wbcg != NULL);
if (gnumeric_dialog_raise_if_exists (wbcg, CELL_SORT_KEY))
return;
gui = gnm_gtk_builder_new ("cell-sort.ui", NULL, GO_CMD_CONTEXT (wbcg));
if (gui == NULL)
return;
state = g_new (SortFlowState, 1);
state->wbcg = wbcg;
state->wb = wb_control_get_workbook (WORKBOOK_CONTROL (wbcg));
state->sv = wb_control_cur_sheet_view (WORKBOOK_CONTROL (wbcg));
state->sheet = sv_sheet (state->sv);
state->warning_dialog = NULL;
state->sel = NULL;
state->sort_items = 0;
state->gui = gui;
state->dialog = go_gtk_builder_get_widget (state->gui, "CellSort");
state->image_ascending =
gtk_widget_render_icon_pixbuf (state->dialog,
GTK_STOCK_SORT_ASCENDING,
GTK_ICON_SIZE_LARGE_TOOLBAR);
state->image_descending =
gtk_widget_render_icon_pixbuf (state->dialog,
GTK_STOCK_SORT_DESCENDING,
GTK_ICON_SIZE_LARGE_TOOLBAR);
dialog_init (state);
gnumeric_keyed_dialog (state->wbcg, GTK_WINDOW (state->dialog),
CELL_SORT_KEY);
gtk_widget_show (state->dialog);
}
static void
cb_data_table_response (GtkWidget *dialog, gint response_id, GnmDialogDataTable *state)
{
if (response_id == GTK_RESPONSE_HELP)
return;
if (response_id == GTK_RESPONSE_OK)
cmd_create_data_table (WORKBOOK_CONTROL (state->wbcg),
state->sheet, &state->input_range,
gnm_expr_entry_get_text (state->col_entry),
gnm_expr_entry_get_text (state->row_entry));
gtk_object_destroy (GTK_OBJECT (dialog));
}
/**
* dialog_preload_selection:
* @state:
* @entry
*
*
**/
static void
dialog_preload_selection (GoalSeekState *state, GnmExprEntry *entry)
{
GnmRange const *sel;
sel = selection_first_range
(wb_control_cur_sheet_view
(WORKBOOK_CONTROL (state->wbcg)), NULL, NULL);
if (sel)
gnm_expr_entry_load_from_range (entry,
state->sheet, sel);
}
static void
cb_dialog_row_height_apply_clicked (G_GNUC_UNUSED GtkWidget *button,
RowHeightState *state)
{
gint value = gtk_spin_button_get_value_as_int (state->spin);
int size_pixels = (int)(value * state->sheet->last_zoom_factor_used + 0.5);
gboolean use_default = gtk_toggle_button_get_active
(GTK_TOGGLE_BUTTON (state->default_check));
if (state->set_default_value) {
double points = value * 72./gnm_app_display_dpi_get (TRUE);
cmd_colrow_std_size (WORKBOOK_CONTROL (state->wbcg),
state->sheet, FALSE, points);
dialog_row_height_load_value (state);
} else {
if (use_default)
size_pixels = 0;
workbook_cmd_resize_selected_colrow (WORKBOOK_CONTROL (state->wbcg),
state->sheet, FALSE, size_pixels);
dialog_row_height_load_value (state);
}
}
static void
wbc_dispose (GObject *obj)
{
WorkbookControl *wbc = WORKBOOK_CONTROL (obj);
if (wbc->clipboard_changed_signal) {
g_signal_handler_disconnect (gnm_app_get_app (),
wbc->clipboard_changed_signal);
wbc->clipboard_changed_signal = 0;
}
if (wbc->wb_view != NULL)
wb_view_detach_control (wbc);
parent_klass->dispose (obj);
}
/**
* scenarios_ok_clicked_cb:
* @button:
* @state:
*
* Run the scenario manager tool.
**/
static void
scenarios_ok_clicked_cb (G_GNUC_UNUSED GtkWidget *button,
ScenariosState *state)
{
if (state->current) {
WorkbookControl *wbc = WORKBOOK_CONTROL (state->base.wbcg);
cmd_scenario_mngr (wbc, state->current, state->undo);
}
scenario_manager_ok (state->base.sheet);
scenario_manager_free (state);
gtk_widget_destroy (state->base.dialog);
return;
}
/**
* dialog_shuffle:
* @wbcg:
* @sheet:
*
* Show the dialog (guru).
*
**/
void
dialog_shuffle (WBCGtk *wbcg)
{
ShuffleState *state;
WorkbookControl *wbc;
GtkWidget *w;
char const *type;
GnmRange const *r;
g_return_if_fail (wbcg != NULL);
wbc = WORKBOOK_CONTROL (wbcg);
/* Only pop up one copy per workbook */
if (gnumeric_dialog_raise_if_exists (wbcg, SHUFFLE_KEY))
return;
state = g_new (ShuffleState, 1);
if (dialog_tool_init (state, wbcg, wb_control_cur_sheet (wbc),
GNUMERIC_HELP_LINK_DATA_SHUFFLE,
"shuffle.ui", "Shuffling",
_("Could not create the Data Shuffling dialog."),
SHUFFLE_KEY,
G_CALLBACK (shuffle_ok_clicked_cb), NULL,
G_CALLBACK (shuffle_update_sensitivity_cb),
0))
return;
shuffle_update_sensitivity_cb (NULL, state);
state->gdao = NULL;
tool_load_selection ((GenericToolState *)state, FALSE);
r = selection_first_range (state->sv, NULL, NULL);
if (range_width (r) == 1)
type = "shuffle_cols";
else if (range_height (r) == 1)
type = "shuffle_rows";
else
type = "shuffle_area";
w = go_gtk_builder_get_widget (state->gui, type);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), TRUE);
gtk_widget_show (state->dialog);
return;
}
static GnmValue *
dialog_goto_get_val (GotoState *state)
{
char const *text = gtk_entry_get_text (state->goto_text);
Sheet *sheet = wb_control_cur_sheet (WORKBOOK_CONTROL (state->wbcg));
GnmValue *val = value_new_cellrange_str (sheet, text);
if (val == NULL) {
GnmParsePos pp;
GnmNamedExpr *nexpr = expr_name_lookup
(parse_pos_init_sheet (&pp, sheet), text);
if (nexpr != NULL && !expr_name_is_placeholder (nexpr)) {
val = gnm_expr_top_get_range (nexpr->texpr);
}
}
return val;
}
static void
cb_dialog_destroy (GoalSeekState *state)
{
if (!state->cancelled
&& state->old_value != NULL
&& state->old_cell != NULL) {
cmd_goal_seek (WORKBOOK_CONTROL(state->wbcg),
state->old_cell, state->old_value, NULL);
state->old_value = NULL;
}
value_release (state->old_value);
if (state->gui != NULL)
g_object_unref (G_OBJECT (state->gui));
wbcg_edit_finish (state->wbcg, WBC_EDIT_REJECT, NULL);
g_free (state);
}
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) ||
gnumeric_dialog_raise_if_exists (wbcg, DIALOG_DATA_TABLE_KEY))
return;
sv = wb_control_cur_sheet_view (WORKBOOK_CONTROL (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;
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);
}
}
static gboolean
vcombo_activate (SheetObject *so, GtkTreeView *list, WBCGtk *wbcg,
G_GNUC_UNUSED gboolean button)
{
GnmValidationCombo *vcombo = GNM_VALIDATION_COMBO (so);
GtkTreeIter iter;
if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (list), NULL, &iter)) {
SheetView *sv = vcombo->parent.sv;
char *strval;
gtk_tree_model_get (gtk_tree_view_get_model (list), &iter,
1, &strval,
-1);
cmd_set_text (WORKBOOK_CONTROL (wbcg),
sv_sheet (sv), &sv->edit_pos, strval, NULL, TRUE);
g_free (strval);
}
return TRUE;
}
static void
cb_cell_comment_ok_clicked (G_GNUC_UNUSED GtkWidget *button,
CommentState *state)
{
char *text;
PangoAttrList *attr;
char const *author;
author = gtk_entry_get_text
(GTK_ENTRY (go_gtk_builder_get_widget
(state->gui, "new-author-entry")));
g_object_get (G_OBJECT (state->gtv), "text", &text,
"attributes", &attr, NULL);
if (!cmd_set_comment (WORKBOOK_CONTROL (state->wbcg),
state->sheet, state->pos, text, attr, author))
gtk_widget_destroy (state->dialog);
g_free (text);
pango_attr_list_unref (attr);
}
static void
cb_dialog_goto_update_sensitivity (G_GNUC_UNUSED GtkWidget *dummy,
GotoState *state)
{
GnmValue *val = dialog_goto_get_val (state);
if (val != NULL) {
gint cols, rows;
Sheet *sheet = val->v_range.cell.a.sheet;
GnmSheetSize const *ssz;
if (sheet == NULL)
sheet = wb_control_cur_sheet (WORKBOOK_CONTROL (state->wbcg));
ssz = gnm_sheet_get_size (sheet);
cols = ssz->max_cols;
rows = ssz->max_rows;
if (val->v_range.cell.a.sheet != NULL &&
val->v_range.cell.b.sheet != NULL &&
val->v_range.cell.a.sheet != val->v_range.cell.b.sheet) {
ssz = gnm_sheet_get_size (sheet);
if (cols > ssz->max_cols)
cols = ssz->max_cols;
if (rows > ssz->max_rows)
cols = ssz->max_rows;
}
cols -= val->v_range.cell.a.col;
rows -= val->v_range.cell.a.row;
if (cols < 1) cols = 1;
if (rows < 1) rows = 1;
gtk_spin_button_set_range (state->spin_cols, 1, cols);
gtk_spin_button_set_range (state->spin_rows, 1, rows);
gtk_widget_set_sensitive (state->go_button, TRUE);
value_release (val);
} else
gtk_widget_set_sensitive (state->go_button, FALSE);
gtk_entry_set_activates_default (state->goto_text, (val != NULL));
}
