void
wb_control_sheet_add (WorkbookControl *wbc, SheetView *sv)
{
WorkbookControlClass *wbc_class;
g_return_if_fail (IS_WORKBOOK_CONTROL (wbc));
wbc_class = WBC_CLASS (wbc);
if (wbc_class != NULL && wbc_class->sheet.add != NULL) {
Sheet *new_sheet = sv_sheet (sv);
wbc_class->sheet.add (wbc, sv);
/* If this is the current sheet init the display */
if (new_sheet == wb_control_cur_sheet (wbc)) {
WorkbookView *wbv = wb_control_view (wbc);
wb_control_sheet_focus (wbc, new_sheet);
wb_view_selection_desc (wbv, TRUE, wbc);
wb_view_edit_line_set (wbv, wbc);
wb_control_style_feedback (wbc, NULL);
wb_control_menu_state_update (wbc, MS_ALL);
wb_control_update_action_sensitivity (wbc);
}
}
}
/**
* cmd_slicer_refresh:
* @wbc: the workbook control.
**/
gboolean
cmd_slicer_refresh (WorkbookControl *wbc)
{
CmdSlicerRefresh *me;
char *r_name;
SheetView *sv = wb_control_cur_sheet_view (wbc);
GnmSheetSlicer *slicer;
slicer = gnm_sheet_slicers_at_pos (sv->sheet, &sv->edit_pos);
if (NULL == slicer)
return FALSE;
me = g_object_new (CMD_SLICER_REFRESH_TYPE, NULL);
me->cmd.sheet = sv_sheet (sv);
me->cmd.size = 1; /* Updated below. */
me->orig_content = NULL;
me->slicer = slicer;
r_name = undo_range_name (me->cmd.sheet,
gnm_sheet_slicer_get_range (slicer));
me->cmd.cmd_descriptor = g_strdup_printf (_("Refreshing DataSlicer in %s"), r_name);
g_free (r_name);
return gnm_command_push_undo (wbc, G_OBJECT (me));
}
/**
* gnm_app_clipboard_cut_copy:
* @wbc: the workbook control that requested the operation.
* @is_cut: is this a cut or a copy.
* @sv: The source sheet for the copy.
* @area: A single rectangular range to be copied.
* @animate_range: Do we want ot add an animated cursor around things.
*
* When Cutting we
* Clear and free the contents of the clipboard and save the sheet and area
* to be cut. DO NOT ACTUALLY CUT! Paste will move the region if this was a
* cut operation.
*
* When Copying we
* Clear and free the contents of the clipboard and COPY the designated region
* into the clipboard.
*
* we need to pass @wbc as a control rather than a simple command-context so
* that the control can claim the selection.
**/
void
gnm_app_clipboard_cut_copy (WorkbookControl *wbc, gboolean is_cut,
SheetView *sv, GnmRange const *area,
gboolean animate_cursor)
{
Sheet *sheet;
g_return_if_fail (IS_SHEET_VIEW (sv));
g_return_if_fail (area != NULL);
g_return_if_fail (app != NULL);
gnm_app_clipboard_clear (FALSE);
sheet = sv_sheet (sv);
g_free (app->clipboard_cut_range);
app->clipboard_cut_range = gnm_range_dup (area);
sv_weak_ref (sv, &(app->clipboard_sheet_view));
if (!is_cut)
app->clipboard_copied_contents =
clipboard_copy_range (sheet, area);
if (animate_cursor) {
GList *l = g_list_append (NULL, (gpointer)area);
sv_ant (sv, l);
g_list_free (l);
}
if (wb_control_claim_selection (wbc)) {
g_signal_emit (G_OBJECT (app), signals[CLIPBOARD_MODIFIED], 0);
} else {
gnm_app_clipboard_clear (FALSE);
g_warning ("Unable to set selection ?");
}
}
/**
* gnm_app_clipboard_cut_copy_obj:
* @wbc: #WorkbookControl
* @is_cut:
* @sv: #SheetView
* @objects: (element-type SheetObject): a list of #SheetObject which is freed
*
* Different than copying/cutting a region, this can actually cuts an object
**/
void
gnm_app_clipboard_cut_copy_obj (WorkbookControl *wbc, gboolean is_cut,
SheetView *sv, GSList *objects)
{
g_return_if_fail (IS_SHEET_VIEW (sv));
g_return_if_fail (objects != NULL);
g_return_if_fail (app != NULL);
gnm_app_clipboard_clear (FALSE);
g_free (app->clipboard_cut_range);
app->clipboard_cut_range = NULL;
sv_weak_ref (sv, &(app->clipboard_sheet_view));
app->clipboard_copied_contents
= clipboard_copy_obj (sv_sheet (sv), objects);
if (is_cut) {
cmd_objects_delete (wbc, objects, _("Cut Object"));
objects = NULL;
}
if (wb_control_claim_selection (wbc)) {
g_signal_emit (G_OBJECT (app), signals[CLIPBOARD_MODIFIED], 0);
} else {
gnm_app_clipboard_clear (FALSE);
g_warning ("Unable to set selection ?");
}
g_slist_free (objects);
}
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;
}
static void
cb_source_expr_changed (DialogDataSlicer *state)
{
GnmValue *range;
range = gnm_expr_entry_parse_as_value
(GNM_EXPR_ENTRY (state->source_expr), sv_sheet (state->sv));
#warning "FIXME: Now what?"
value_release (range);
}
/**
* gnm_app_clipboard_sheet_get:
*
* Returns: (transfer none): the current clipboard #Sheet.
**/
Sheet *
gnm_app_clipboard_sheet_get (void)
{
g_return_val_if_fail (app != NULL, NULL);
if (app->clipboard_sheet_view == NULL)
return NULL;
return sv_sheet (app->clipboard_sheet_view);
}
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);
}
}
static void
cb_colrow_visibility (SheetView *sv, GnmRange const *r, gpointer closure)
{
ColRowVisiblity * const dat = (ColRowVisiblity *)closure;
int first, last;
if (dat->is_cols) {
first = r->start.col;
last = r->end.col;
} else {
first = r->start.row;
last = r->end.row;
}
colrow_visibility (sv_sheet (sv), dat, first, last);
}
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;
}
/*
* 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);
}
void
dialog_so_size (WBCGtk *wbcg, GObject *so)
{
GtkBuilder *gui;
SOSizeState *state;
int width, height;
g_return_if_fail (wbcg != NULL);
if (gnumeric_dialog_raise_if_exists (wbcg, SO_SIZE_DIALOG_KEY))
return;
gui = gnm_gtk_builder_load ("sheetobject-size.ui", NULL, GO_CMD_CONTEXT (wbcg));
if (gui == NULL)
return;
state = g_new (SOSizeState, 1);
state->wbcg = wbcg;
state->sv = wb_control_cur_sheet_view (WORKBOOK_CONTROL (wbcg));
state->sheet = sv_sheet (state->sv);
state->scg = wbcg_get_nth_scg (wbcg, state->sheet->index_in_wb);
state->gui = gui;
state->dialog = go_gtk_builder_get_widget (state->gui, "object-size");
state->so = SHEET_OBJECT (so);
g_object_ref (so);
state->nameentry = GTK_ENTRY (go_gtk_builder_get_widget (state->gui, "name-entry"));
state->old_anchor = NULL;
state->old_name = NULL;
g_object_get (so, "name", &state->old_name, NULL);
if (state->old_name == NULL)
state->old_name = g_strdup ("");
gtk_entry_set_text (state->nameentry, state->old_name);
state->so_name_changed = FALSE;
g_signal_connect (G_OBJECT (state->nameentry),
"focus-out-event",
G_CALLBACK (cb_dialog_so_size_name_changed),
state);
state->so_print_check_changed = FALSE;
state->wpoints = GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "w-pts-label"));
state->wspin = GTK_SPIN_BUTTON (go_gtk_builder_get_widget (state->gui, "w-spin"));
state->hpoints = GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "h-pts-label"));
state->hspin = GTK_SPIN_BUTTON (go_gtk_builder_get_widget (state->gui, "h-spin"));
state->xpoints = GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "x-pts-label"));
state->xspin = GTK_SPIN_BUTTON (go_gtk_builder_get_widget (state->gui, "x-spin"));
state->ypoints = GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "y-pts-label"));
state->yspin = GTK_SPIN_BUTTON (go_gtk_builder_get_widget (state->gui, "y-spin"));
state->print_check = GTK_WIDGET (go_gtk_builder_get_widget (state->gui,
"print-check"));
dialog_so_size_load (state);
state->active_anchor = sheet_object_anchor_dup (sheet_object_get_anchor
(state->so));
width = state->coords[2] - state->coords[0];
height = state->coords[3] - state->coords[1];
gtk_spin_button_set_value (state->wspin, (width < 0) ? - width : width);
gtk_spin_button_set_value (state->hspin, (height < 0) ? - height : height);
gtk_spin_button_set_value (state->xspin, 0.);
gtk_spin_button_set_value (state->yspin, 0.);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (state->print_check),
!(state->so->flags & SHEET_OBJECT_PRINT));
g_signal_connect (G_OBJECT (state->wspin),
"value-changed",
G_CALLBACK (cb_dialog_so_size_value_changed_update_points),
state->wpoints);
g_signal_connect (G_OBJECT (state->hspin),
"value-changed",
G_CALLBACK (cb_dialog_so_size_value_changed_update_points),
state->hpoints);
g_signal_connect (G_OBJECT (state->xspin),
"value-changed",
G_CALLBACK (cb_dialog_so_size_value_changed_update_points),
state->xpoints);
g_signal_connect (G_OBJECT (state->yspin),
"value-changed",
G_CALLBACK (cb_dialog_so_size_value_changed_update_points),
state->ypoints);
g_signal_connect (G_OBJECT (state->print_check),
"toggled",
G_CALLBACK (cb_dialog_so_size_print_check_toggled),
state);
cb_dialog_so_size_value_changed_update_points (state->wspin, GTK_LABEL (state->wpoints));
cb_dialog_so_size_value_changed_update_points (state->hspin, GTK_LABEL (state->hpoints));
cb_dialog_so_size_value_changed_update_points (state->xspin, GTK_LABEL (state->xpoints));
cb_dialog_so_size_value_changed_update_points (state->yspin, GTK_LABEL (state->ypoints));
g_signal_connect (G_OBJECT (state->wspin),
"value-changed",
G_CALLBACK (cb_dialog_so_size_value_changed), state);
g_signal_connect (G_OBJECT (state->hspin),
"value-changed",
G_CALLBACK (cb_dialog_so_size_value_changed), state);
g_signal_connect (G_OBJECT (state->xspin),
"value-changed",
G_CALLBACK (cb_dialog_so_size_value_changed), state);
g_signal_connect (G_OBJECT (state->yspin),
"value-changed",
G_CALLBACK (cb_dialog_so_size_value_changed), state);
state->ok_button = go_gtk_builder_get_widget (state->gui, "ok_button");
g_signal_connect (G_OBJECT (state->ok_button),
"clicked",
G_CALLBACK (cb_dialog_so_size_ok_clicked), state);
state->apply_button = go_gtk_builder_get_widget (state->gui, "apply_button");
g_signal_connect (G_OBJECT (state->apply_button),
"clicked",
G_CALLBACK (cb_dialog_so_size_apply_clicked), state);
state->cancel_button = go_gtk_builder_get_widget (state->gui, "cancel_button");
g_signal_connect (G_OBJECT (state->cancel_button),
"clicked",
G_CALLBACK (cb_dialog_so_size_cancel_clicked), state);
gnumeric_init_help_button (
go_gtk_builder_get_widget (state->gui, "help_button"),
GNUMERIC_HELP_LINK_SO_SIZE);
gnm_dialog_setup_destroy_handlers (GTK_DIALOG (state->dialog),
state->wbcg,
GNM_DIALOG_DESTROY_CURRENT_SHEET_REMOVED);
wbc_gtk_attach_guru (state->wbcg, state->dialog);
g_object_set_data_full (G_OBJECT (state->dialog),
"state", state, (GDestroyNotify) cb_dialog_so_size_destroy);
gnumeric_keyed_dialog (wbcg, GTK_WINDOW (state->dialog),
SO_SIZE_DIALOG_KEY);
dialog_so_size_button_sensitivity (state);
gtk_widget_show (state->dialog);
}
/**
* stf_text_to_columns:
* @wbc: The control making the request
* @cc:
*
* Main routine, handles importing a file including all dialog mumbo-jumbo
**/
void
stf_text_to_columns (WorkbookControl *wbc, GOCmdContext *cc)
{
DialogStfResult_t *dialogresult = NULL;
SheetView *sv;
Sheet *src_sheet, *target_sheet;
GnmRange const *src;
GnmRange target;
GsfOutput *buf;
guint8 const *data;
size_t data_len;
sv = wb_control_cur_sheet_view (wbc);
src_sheet = sv_sheet (sv);
src = selection_first_range (sv, cc, _("Text to Columns"));
if (src == NULL)
return;
if (range_width (src) > 1) {
go_cmd_context_error (cc, g_error_new (go_error_invalid (), 0,
_("Only one column of input data can be parsed at a time")));
return;
}
/* FIXME : how to do this cleanly ? */
if (!GNM_IS_WBC_GTK (wbc))
return;
#warning Add UI for this
target_sheet = src_sheet;
target = *src;
range_translate (&target, target_sheet, 1, 0);
buf = gsf_output_memory_new ();
sheet_foreach_cell_in_range (src_sheet,
CELL_ITER_ALL,
src->start.col, src->start.row,
src->end.col, src->end.row,
(CellIterFunc) &cb_get_content, buf);
gsf_output_close (buf);
data = gsf_output_memory_get_bytes (GSF_OUTPUT_MEMORY (buf));
data_len = (size_t)gsf_output_size (buf);
if (data_len == 0) {
go_cmd_context_error_import (GO_CMD_CONTEXT (cc),
_("There is no data "
"to convert"));
} else {
dialogresult = stf_dialog (WBC_GTK (wbc),
NULL, FALSE, NULL, FALSE,
_("Text to Columns"),
data, data_len);
}
if (dialogresult != NULL) {
GnmCellRegion *cr = stf_parse_region (dialogresult->parseoptions,
dialogresult->text, NULL, target_sheet->workbook);
if (cr != NULL) {
stf_dialog_result_attach_formats_to_cr (dialogresult, cr);
target.end.col = target.start.col + cr->cols - 1;
target.end.row = target.start.row + cr->rows - 1;
}
if (cr == NULL ||
cmd_text_to_columns (wbc, src, src_sheet,
&target, target_sheet, cr))
go_cmd_context_error_import (GO_CMD_CONTEXT (cc),
_("Error while trying to "
"parse data into sheet"));
stf_dialog_result_free (dialogresult);
}
g_object_unref (buf);
}
/**
* sv_select_cur_depends :
* @sv: The sheet
*
* Select all cells that depend on the expression in the current cell.
*/
void
sv_select_cur_depends (SheetView *sv)
{
GnmCell *cur_cell, dummy;
GList *deps = NULL, *ptr = NULL;
g_return_if_fail (IS_SHEET_VIEW (sv));
cur_cell = sheet_cell_get (sv->sheet,
sv->edit_pos.col, sv->edit_pos.row);
if (cur_cell == NULL) {
dummy.base.sheet = sv_sheet (sv);
dummy.pos = sv->edit_pos;
cur_cell = &dummy;
}
cell_foreach_dep (cur_cell, cb_collect_deps, &deps);
if (deps == NULL)
return;
sv_selection_reset (sv);
/* Short circuit */
if (g_list_length (deps) == 1) {
GnmCell *cell = deps->data;
sv_selection_add_pos (sv, cell->pos.col, cell->pos.row);
} else {
GnmRange *cur = NULL;
ptr = NULL;
/* Merge the sorted list of cells into rows */
for (deps = g_list_sort (deps, &cb_compare_deps) ; deps ; ) {
GnmCell *cell = deps->data;
if (cur == NULL ||
cur->end.row != cell->pos.row ||
cur->end.col+1 != cell->pos.col) {
if (cur)
ptr = g_list_prepend (ptr, cur);
cur = g_new (GnmRange, 1);
cur->start.row = cur->end.row = cell->pos.row;
cur->start.col = cur->end.col = cell->pos.col;
} else
cur->end.col = cell->pos.col;
deps = g_list_remove (deps, cell);
}
if (cur)
ptr = g_list_prepend (ptr, cur);
/* Merge the coalesced rows into ranges */
deps = ptr;
for (ptr = NULL ; deps ; ) {
GnmRange *r1 = deps->data;
GList *fwd;
for (fwd = deps->next ; fwd ; ) {
GnmRange *r2 = fwd->data;
if (r1->start.col == r2->start.col &&
r1->end.col == r2->end.col &&
r1->start.row-1 == r2->end.row) {
r1->start.row = r2->start.row;
g_free (fwd->data);
fwd = g_list_remove (fwd, r2);
} else
fwd = fwd->next;
}
ptr = g_list_prepend (ptr, r1);
deps = g_list_remove (deps, r1);
}
/* now select the ranges */
while (ptr) {
sv_selection_add_range (sv, ptr->data);
g_free (ptr->data);
ptr = g_list_remove (ptr, ptr->data);
}
}
sheet_update (sv->sheet);
}
static int
item_grid_button_pressed (GocItem *item, int button, double x_, double y_)
{
GnmItemGrid *ig = GNM_ITEM_GRID (item);
GocCanvas *canvas = item->canvas;
GnmPane *pane = GNM_PANE (canvas);
SheetControlGUI *scg = ig->scg;
WBCGtk *wbcg = scg_wbcg (scg);
SheetControl *sc = (SheetControl *)scg;
SheetView *sv = sc_view (sc);
Sheet *sheet = sv_sheet (sv);
GnmCellPos pos;
gboolean edit_showed_dialog;
gboolean already_selected;
GdkEvent *event = goc_canvas_get_cur_event (item->canvas);
gint64 x = x_ * canvas->pixels_per_unit, y = y_ * canvas->pixels_per_unit;
gnm_pane_slide_stop (pane);
pos.col = gnm_pane_find_col (pane, x, NULL);
pos.row = gnm_pane_find_row (pane, y, NULL);
/* GnmRange check first */
if (pos.col >= gnm_sheet_get_max_cols (sheet))
return TRUE;
if (pos.row >= gnm_sheet_get_max_rows (sheet))
return TRUE;
/* A new object is ready to be realized and inserted */
if (wbcg->new_object != NULL)
return ig_obj_create_begin (ig, button, x, y);
/* If we are not configuring an object then clicking on the sheet
* ends the edit. */
if (scg->selected_objects == NULL)
wbcg_focus_cur_scg (wbcg);
else if (wbc_gtk_get_guru (wbcg) == NULL)
scg_mode_edit (scg);
/* If we were already selecting a range of cells for a formula,
* reset the location to a new place, or extend the selection.
*/
if (button == 1 && scg->rangesel.active) {
ig->selecting = GNM_ITEM_GRID_SELECTING_FORMULA_RANGE;
if (event->button.state & GDK_SHIFT_MASK)
scg_rangesel_extend_to (scg, pos.col, pos.row);
else
scg_rangesel_bound (scg, pos.col, pos.row, pos.col, pos.row);
gnm_pane_slide_init (pane);
gnm_simple_canvas_grab (item,
GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK,
NULL, gdk_event_get_time (event));
return TRUE;
}
/* If the user is editing a formula (wbcg_rangesel_possible) then we
* enable the dynamic cell selection mode.
*/
if (button == 1 && wbcg_rangesel_possible (wbcg)) {
scg_rangesel_start (scg, pos.col, pos.row, pos.col, pos.row);
ig->selecting = GNM_ITEM_GRID_SELECTING_FORMULA_RANGE;
gnm_pane_slide_init (pane);
gnm_simple_canvas_grab (item,
GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK,
NULL, gdk_event_get_time (event));
return TRUE;
}
/* While a guru is up ignore clicks */
if (wbc_gtk_get_guru (wbcg) != NULL)
return TRUE;
/* This was a regular click on a cell on the spreadsheet. Select it.
* but only if the entered expression is valid */
if (!wbcg_edit_finish (wbcg, WBC_EDIT_ACCEPT, &edit_showed_dialog))
return TRUE;
if (button == 1 && !sheet_selection_is_allowed (sheet, &pos))
return TRUE;
/* Button == 1 is used to trigger hyperlinks (and possibly similar */
/* special cases. Otherwise button == 2 should behave exactly like */
/* button == 1. See bug #700792 */
/* buttons 1 and 2 will always change the selection, the other buttons will
* only effect things if the target is not already selected. */
already_selected = sv_is_pos_selected (sv, pos.col, pos.row);
if (button == 1 || button == 2 || !already_selected) {
if (!(event->button.state & (GDK_CONTROL_MASK|GDK_SHIFT_MASK)))
sv_selection_reset (sv);
if ((event->button.button != 1 && event->button.button != 2)
|| !(event->button.state & GDK_SHIFT_MASK) ||
sv->selections == NULL) {
sv_selection_add_pos (sv, pos.col, pos.row,
(already_selected && (event->button.state & GDK_CONTROL_MASK)) ?
GNM_SELECTION_MODE_REMOVE :
GNM_SELECTION_MODE_ADD);
sv_make_cell_visible (sv, pos.col, pos.row, FALSE);
} else sv_selection_extend_to (sv, pos.col, pos.row);
sheet_update (sheet);
}
if (edit_showed_dialog)
return TRUE; /* we already ignored the button release */
switch (button) {
case 1:
case 2: {
guint32 double_click_time;
/*
* If the second click is on a different cell than the
* first one this cannot be a double-click
*/
if (already_selected) {
g_object_get (gtk_widget_get_settings (GTK_WIDGET (canvas)),
"gtk-double-click-time", &double_click_time,
NULL);
if ((ig->last_click_time + double_click_time) > gdk_event_get_time (event) &&
wbcg_edit_start (wbcg, FALSE, FALSE)) {
break;
}
}
ig->last_click_time = gdk_event_get_time (event);
ig->selecting = GNM_ITEM_GRID_SELECTING_CELL_RANGE;
gnm_pane_slide_init (pane);
gnm_simple_canvas_grab (item,
GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK,
NULL, gdk_event_get_time (event));
break;
}
case 3: scg_context_menu (scg, event, FALSE, FALSE);
break;
default :
break;
}
return TRUE;
}
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);
}
void
dialog_row_height (WBCGtk *wbcg, gboolean use_default)
{
RowHeightState *state;
g_return_if_fail (wbcg != NULL);
if (gnm_dialog_raise_if_exists (wbcg, ROW_HEIGHT_DIALOG_KEY))
return;
state = g_new (RowHeightState, 1);
state->wbcg = wbcg;
state->sv = wb_control_cur_sheet_view (GNM_WBC (wbcg));
state->sheet = sv_sheet (state->sv);
state->adjusting = FALSE;
state->gui = gnm_gtk_builder_load ("row-height.ui", NULL, GO_CMD_CONTEXT (wbcg));
g_return_if_fail (state->gui != NULL);
state->dialog = go_gtk_builder_get_widget (state->gui, "dialog");
state->description = GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "description"));
state->points = GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "pts-label"));
state->spin = GTK_SPIN_BUTTON (go_gtk_builder_get_widget (state->gui, "spin"));
gtk_adjustment_set_lower (gtk_spin_button_get_adjustment (state->spin),
GNM_ROW_MARGIN + GNM_ROW_MARGIN + 1);
g_signal_connect (G_OBJECT (state->spin),
"value-changed",
G_CALLBACK (cb_dialog_row_height_value_changed), state);
state->default_check = GTK_WIDGET (go_gtk_builder_get_widget (state->gui, "default_check"));
g_signal_connect (G_OBJECT (state->default_check),
"clicked",
G_CALLBACK (cb_dialog_row_height_default_check_toggled), state);
state->ok_button = go_gtk_builder_get_widget (state->gui, "ok_button");
g_signal_connect (G_OBJECT (state->ok_button),
"clicked",
G_CALLBACK (cb_dialog_row_height_ok_clicked), state);
state->apply_button = go_gtk_builder_get_widget (state->gui, "apply_button");
g_signal_connect (G_OBJECT (state->apply_button),
"clicked",
G_CALLBACK (cb_dialog_row_height_apply_clicked), state);
state->cancel_button = go_gtk_builder_get_widget (state->gui, "cancel_button");
g_signal_connect (G_OBJECT (state->cancel_button),
"clicked",
G_CALLBACK (cb_dialog_row_height_cancel_clicked), state);
gnm_init_help_button (
go_gtk_builder_get_widget (state->gui, "help_button"),
GNUMERIC_HELP_LINK_ROW_HEIGHT);
g_object_set_data_full (G_OBJECT (state->dialog),
"state", state, (GDestroyNotify) cb_dialog_row_height_destroy);
gnm_dialog_setup_destroy_handlers (GTK_DIALOG (state->dialog),
state->wbcg,
GNM_DIALOG_DESTROY_CURRENT_SHEET_REMOVED);
dialog_row_height_set_mode (use_default, state);
dialog_row_height_load_value (state);
wbc_gtk_attach_guru (state->wbcg, state->dialog);
gnm_keyed_dialog (wbcg, GTK_WINDOW (state->dialog),
ROW_HEIGHT_DIALOG_KEY);
gtk_widget_show (state->dialog);
}