static void
gnm_stf_file_saver_save (G_GNUC_UNUSED GOFileSaver const *fs, GOIOContext *context,
GoView const *view, GsfOutput *output)
{
WorkbookView *wbv = GNM_WORKBOOK_VIEW (view);
Workbook *wb = wb_view_get_workbook (wbv);
GnmStfExport *stfe = gnm_stf_get_stfe (G_OBJECT (wb));
GsfOutput *dummy_sink;
/* TODO: move this GUI dependent code out of this
* filesaver into gui-file.c. After this, remove includes (see above). */
if (GNM_IS_WBC_GTK (context->impl)) {
gboolean cancelled =
stf_export_dialog (WBC_GTK (context->impl), stfe, wb);
if (cancelled) {
go_io_error_unknown (context);
return;
}
}
if (!stfe->sheet_list)
gnm_stf_export_options_sheet_list_add
(stfe, wb_view_cur_sheet (wbv));
g_object_set (G_OBJECT (stfe), "sink", output, NULL);
if (gnm_stf_export (stfe) == FALSE)
go_cmd_context_error_import (GO_CMD_CONTEXT (context),
_("Error while trying to export file as text"));
/* We're not allowed to set a NULL sink, so use a dummy. */
dummy_sink = gsf_output_memory_new ();
g_object_set (G_OBJECT (stfe), "sink", dummy_sink, NULL);
g_object_unref (dummy_sink);
}
static void
wbcg_edit_attach_guru_main (WBCGtk *wbcg, GtkWidget *guru)
{
WorkbookControl *wbc = GNM_WBC (wbcg);
g_return_if_fail (guru != NULL);
g_return_if_fail (GNM_IS_WBC_GTK (wbcg));
g_return_if_fail (wbcg->edit_line.guru == NULL);
/* Make sure we don't have anything anted.
* this protects against two anted regions showing up
*/
gnm_app_clipboard_unant ();
/* don't set end 'End' mode when a dialog comes up */
wbcg_set_end_mode (wbcg, FALSE);
wbcg->edit_line.guru = guru;
gtk_editable_set_editable (GTK_EDITABLE (wbcg_get_entry (wbcg)), FALSE);
wb_control_update_action_sensitivity (wbc);
wb_control_menu_state_update (wbc, MS_GURU_MENU_ITEMS);
g_signal_connect_object (guru, "destroy",
G_CALLBACK (wbc_gtk_detach_guru), wbcg, G_CONNECT_SWAPPED);
}
/**
* wbcg_insert_object:
* @wbcg: #WBCGtk *
* @so: The object the needs to be placed
*
* Takes a newly created #SheetObject that has not yet been realized and
* prepares to place it on the sheet.
*
* NOTE : Absorbs a reference to the object.
**/
void
wbcg_insert_object (WBCGtk *wbcg, SheetObject *so)
{
int i, npages;
SheetControlGUI *scg;
g_return_if_fail (GNM_IS_WBC_GTK (wbcg));
g_return_if_fail (GNM_IS_SO (so));
wbcg_insert_object_clear (wbcg);
npages = wbcg_get_n_scg (wbcg);
for (i = 0; i < npages; i++) {
if (NULL != (scg = wbcg_get_nth_scg (wbcg, i))) {
scg_object_unselect (scg, NULL);
scg_cursor_visible (scg, FALSE);
scg_set_display_cursor (scg);
sc_unant (GNM_SC (scg));
}
}
/* we can't set wbcg->new_object before now because if one sheet has a
* selected object, the new object will be destroyed by the loop
* above. See #669648. */
wbcg->new_object = so;
wb_control_update_action_sensitivity (GNM_WBC (wbcg));
}
/*
* stf_read_workbook:
* @fo: file opener
* @enc: encoding of file
* @context: command context
* @book: workbook
* @input: file to read from+convert
*
* Main routine, handles importing a file including all dialog mumbo-jumbo
*/
static void
stf_read_workbook (G_GNUC_UNUSED GOFileOpener const *fo, gchar const *enc,
GOIOContext *context, GoView *view, GsfInput *input)
{
DialogStfResult_t *dialogresult = NULL;
char *name, *nameutf8 = NULL;
char *data = NULL;
size_t data_len;
WorkbookView *wbv = GNM_WORKBOOK_VIEW (view);
if (!GNM_IS_WBC_GTK (context->impl)) {
go_io_error_string (context, _("This importer can only be used with a GUI."));
return;
}
name = g_path_get_basename (gsf_input_name (input));
nameutf8 = g_filename_to_utf8 (name, -1, NULL, NULL, NULL);
g_free (name);
if (!nameutf8) {
g_warning ("Failed to convert filename to UTF-8. This shouldn't happen here.");
goto out;
}
data = stf_preparse (context, input, &data_len);
if (!data)
goto out;
dialogresult = stf_dialog (WBC_GTK (context->impl),
enc, FALSE, NULL, FALSE,
nameutf8, data, data_len);
if (dialogresult != NULL) {
Workbook *book = wb_view_get_workbook (wbv);
int cols = dialogresult->colcount, rows = dialogresult->rowcount;
Sheet *sheet;
gnm_sheet_suggest_size (&cols, &rows);
sheet = sheet_new (book, nameutf8, cols, rows);
workbook_sheet_attach (book, sheet);
if (stf_store_results (dialogresult, sheet, 0, 0)) {
workbook_recalc_all (book);
resize_columns (sheet);
workbook_set_saveinfo
(book,
GO_FILE_FL_WRITE_ONLY,
go_file_saver_for_id
("Gnumeric_stf:stf_assistant"));
} else {
/* the user has cancelled */
/* the caller should notice that we have no sheets */
workbook_sheet_delete (sheet);
}
}
out:
g_free (nameutf8);
g_free (data);
if (dialogresult != NULL)
stf_dialog_result_free (dialogresult);
}
/**
* wbcg_get_entry:
* @wbcg: #WBCGtk
*
* Returns: (transfer none): the #GtkEntry associated with the current GnmExprEntry
**/
GtkEntry *
wbcg_get_entry (WBCGtk const *wbcg)
{
g_return_val_if_fail (GNM_IS_WBC_GTK (wbcg), NULL);
g_return_val_if_fail (wbcg != NULL, NULL);
return gnm_expr_entry_get_entry (wbcg->edit_line.entry);
}
void
wbc_gtk_attach_guru (WBCGtk *wbcg, GtkWidget *guru)
{
g_return_if_fail (guru != NULL);
g_return_if_fail (GNM_IS_WBC_GTK (wbcg));
wbcg_edit_attach_guru_main (wbcg, guru);
g_signal_connect_object (G_OBJECT (guru), "set-focus",
G_CALLBACK (cb_guru_set_focus), wbcg, 0);
}
void
wbcg_set_entry (WBCGtk *wbcg, GnmExprEntry *entry)
{
g_return_if_fail (GNM_IS_WBC_GTK (wbcg));
if (wbcg->edit_line.temp_entry != entry) {
scg_rangesel_stop (wbcg_cur_scg (wbcg), FALSE);
wbcg->edit_line.temp_entry = entry;
}
}
void
wbc_gtk_attach_guru_with_unfocused_rs (WBCGtk *wbcg, GtkWidget *guru,
GnmExprEntry *gee)
{
g_return_if_fail (guru != NULL);
g_return_if_fail (GNM_IS_WBC_GTK (wbcg));
wbcg_edit_attach_guru_main (wbcg, guru);
if (gnm_conf_get_dialogs_rs_unfocused ()) {
if (gee)
wbcg_set_entry (wbcg, gee);
} else
g_signal_connect (G_OBJECT (guru), "set-focus",
G_CALLBACK (cb_guru_set_focus), wbcg);
}
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);
}
void
wbc_gtk_init_editline (WBCGtk *wbcg)
{
g_assert (GNM_IS_WBC_GTK (wbcg));
g_assert (wbcg->edit_line.entry == NULL);
wbcg->edit_line.entry = g_object_new (GNM_EXPR_ENTRY_TYPE,
"with-icon", FALSE,
"wbcg", wbcg,
NULL);
wbcg->edit_line.temp_entry = NULL;
wbcg->edit_line.guru = NULL;
wbcg->edit_line.signal_changed = 0;
wbcg->edit_line.full_content = NULL;
wbcg->edit_line.markup = NULL;
wbcg->edit_line.cur_fmt = NULL;
}
void
wbc_gtk_detach_guru (WBCGtk *wbcg)
{
WorkbookControl *wbc = GNM_WBC (wbcg);
g_return_if_fail (GNM_IS_WBC_GTK (wbcg));
/* don't sit end 'End' mode when a dialog comes up */
wbcg_set_end_mode (wbcg, FALSE);
if (wbcg->edit_line.guru == NULL)
return;
wbcg_set_entry (wbcg, NULL);
wbcg->edit_line.guru = NULL;
gtk_editable_set_editable (GTK_EDITABLE (wbcg_get_entry (wbcg)), TRUE);
wb_control_update_action_sensitivity (wbc);
wb_control_menu_state_update (wbc, MS_GURU_MENU_ITEMS);
}
/**
* wbcg_insert_object_clear:
* @wbcg: #WBCGtk
*
* If we are preparing to insert a new object, unref the object, and restore
* a normal state to the scgs that was changed in wbcg_insert_object
* (e.g. visiblity of cursors)
**/
void
wbcg_insert_object_clear (WBCGtk *wbcg)
{
g_return_if_fail (GNM_IS_WBC_GTK (wbcg));
if (NULL != wbcg->new_object) {
int i, npages;
SheetControlGUI *scg;
g_object_unref (wbcg->new_object);
wbcg->new_object = NULL;
npages = wbcg_get_n_scg (wbcg);
for (i = 0; i < npages; i++)
if (NULL != (scg = wbcg_get_nth_scg (wbcg, i)))
scg_cursor_visible (scg, TRUE);
}
}
static void
cb_view_ok_clicked (G_GNUC_UNUSED GtkWidget *button,
ViewState *state)
{
WBCGtk *wbcg = state->wbcg;
WorkbookControl *wbc = GNM_WBC (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 = workbook_control_new_wrapper
(wbc,
shared ? wb_control_view (wbc) : NULL,
wb_control_get_workbook (wbc),
screen);
if (GNM_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 ();
}
}
/**
* wbcg_edit_finish:
* @wbcg: #WBCGtk
* @result: what should we do with the content
* @showed_dialog: If non-NULL will indicate if a dialog was displayed.
*
* Return: TRUE if editing completed successfully, or we were no editing.
**/
gboolean
wbcg_edit_finish (WBCGtk *wbcg, WBCEditResult result,
gboolean *showed_dialog)
{
Sheet *sheet;
SheetView *sv;
WorkbookControl *wbc;
WorkbookView *wbv;
g_return_val_if_fail (GNM_IS_WBC_GTK (wbcg), FALSE);
wbc = GNM_WBC (wbcg);
wbv = wb_control_view (wbc);
wbcg_focus_cur_scg (wbcg);
gnm_expr_entry_close_tips (wbcg_get_entry_logical (wbcg));
if (showed_dialog != NULL)
*showed_dialog = FALSE;
/* Remove the range selection cursor if it exists */
if (NULL != wbcg->rangesel)
scg_rangesel_stop (wbcg->rangesel, result == WBC_EDIT_REJECT);
if (!wbcg_is_editing (wbcg)) {
/* We may have a guru up even if we are not editing. remove it.
* Do NOT remove until later it if we are editing, it is possible
* that we may want to continue editing.
*/
if (wbcg->edit_line.guru != NULL) {
GtkWidget *w = wbcg->edit_line.guru;
wbc_gtk_detach_guru (wbcg);
gtk_widget_destroy (w);
}
return TRUE;
}
g_return_val_if_fail (IS_SHEET (wbcg->editing_sheet), TRUE);
sheet = wbcg->editing_sheet;
sv = sheet_get_view (sheet, wbv);
/* Save the results before changing focus */
if (result != WBC_EDIT_REJECT) {
ValidationStatus valid = GNM_VALIDATION_STATUS_VALID;
char *free_txt = NULL;
char const *txt;
GnmStyle const *mstyle;
char const *expr_txt = NULL;
GOFormat const *fmt;
GnmValue *value;
GOUndo *u = NULL;
GSList *selection = selection_get_ranges (sv, FALSE);
GnmParsePos pp;
GnmExprTop const *texpr = NULL;
parse_pos_init_editpos (&pp, sv);
/* Array only works on single range. */
if (result == WBC_EDIT_ACCEPT_ARRAY &&
(selection == NULL || selection->next != NULL))
result = WBC_EDIT_ACCEPT_RANGE;
/******* Check whether we would split a range ********/
switch (result) {
case (WBC_EDIT_ACCEPT_RANGE):
case (WBC_EDIT_ACCEPT_ARRAY): {
if (sheet_ranges_split_region (sheet, selection,
GO_CMD_CONTEXT (wbc), _("Set Text"))) {
range_fragment_free (selection);
if (showed_dialog != NULL)
*showed_dialog = TRUE;
return FALSE;
}
if (result == WBC_EDIT_ACCEPT_ARRAY &&
sheet_range_contains_merges_or_arrays
(sheet, selection->data,
GO_CMD_CONTEXT (wbc), _("Set Text"),
TRUE, FALSE)) {
range_fragment_free (selection);
if (showed_dialog != NULL)
*showed_dialog = TRUE;
return FALSE;
}
break;
}
case (WBC_EDIT_ACCEPT_WO_AC):
case (WBC_EDIT_ACCEPT): {
GnmCell const *cell = sheet_cell_get
(sheet, sv->edit_pos.col, sv->edit_pos.row);
if (gnm_cell_is_nonsingleton_array (cell)) {
gnm_cmd_context_error_splits_array (GO_CMD_CONTEXT (wbc),
_("Set Text"), NULL);
if (showed_dialog != NULL)
*showed_dialog = TRUE;
range_fragment_free (selection);
return FALSE;
}
break;
}
case (WBC_EDIT_REJECT):
default:
/* We should not be able to get here! */
break;
}
/******* Check whether the range is locked ********/
switch (result) {
case (WBC_EDIT_ACCEPT_RANGE):
case (WBC_EDIT_ACCEPT_ARRAY): {
if (cmd_selection_is_locked_effective (sheet, selection, wbc,
_("Set Text"))) {
range_fragment_free (selection);
if (showed_dialog != NULL)
*showed_dialog = TRUE;
return FALSE;
}
break;
}
case (WBC_EDIT_ACCEPT_WO_AC):
case (WBC_EDIT_ACCEPT): {
GnmRange r;
r.end = r.start = pp.eval;
if (cmd_cell_range_is_locked_effective (sheet, &r, wbc,
_("Set Text"))) {
range_fragment_free (selection);
if (showed_dialog != NULL)
*showed_dialog = TRUE;
return FALSE;
}
break;
}
case (WBC_EDIT_REJECT):
default:
/* We should not be able to get here! */
break;
}
/*****************************************************/
txt = wbcg_edit_get_display_text (wbcg);
mstyle = sheet_style_get (sheet, sv->edit_pos.col, sv->edit_pos.row);
fmt = gnm_cell_get_format (sheet_cell_fetch (sheet, sv->edit_pos.col,
sv->edit_pos.row));
value = format_match (txt, fmt,
workbook_date_conv (sheet->workbook));
if (value == NULL)
expr_txt = gnm_expr_char_start_p (txt);
else
value_release (value);
/* NOTE : do not modify gnm_expr_char_start_p to exclude "-"
* it _can_ start an expression, which is required for rangesel
* it just isn't an expression. */
if (expr_txt != NULL && *expr_txt != '\0' && strcmp (expr_txt, "-")) {
GnmExprTop const *texpr_test = NULL;
GnmParseError perr;
parse_error_init (&perr);
texpr_test = gnm_expr_parse_str (expr_txt,
&pp, GNM_EXPR_PARSE_DEFAULT, NULL, &perr);
/* Try adding a single extra closing paren to see if it helps */
if (texpr_test == NULL && perr.err != NULL &&
perr.err->code == PERR_MISSING_PAREN_CLOSE) {
GnmParseError tmp_err;
char *tmp = g_strconcat (txt, ")", NULL);
parse_error_init (&tmp_err);
texpr_test = gnm_expr_parse_str (gnm_expr_char_start_p (tmp),
&pp, GNM_EXPR_PARSE_DEFAULT,
NULL, &tmp_err);
parse_error_free (&tmp_err);
if (texpr_test != NULL) {
txt = free_txt = tmp;
expr_txt = gnm_expr_char_start_p (txt);
} else
g_free (tmp);
}
if (texpr_test == NULL && perr.err != NULL) {
ValidationStatus reedit;
/* set focus _before_ selection. gtk2 seems to
* screw with selection in gtk_entry_grab_focus
* (no longer required now that we clear
* gtk-entry-select-on-focus) */
gtk_window_set_focus (wbcg_toplevel (wbcg),
(GtkWidget *) wbcg_get_entry (wbcg));
if (perr.begin_char != 0 || perr.end_char != 0) {
int offset = expr_txt - txt;
gtk_editable_select_region (GTK_EDITABLE (wbcg_get_entry (wbcg)),
offset + perr.begin_char,
offset + perr.end_char);
} else
gtk_editable_set_position (
GTK_EDITABLE (wbcg_get_entry (wbcg)), -1);
reedit = wb_control_validation_msg (GNM_WBC (wbcg),
GNM_VALIDATION_STYLE_PARSE_ERROR, NULL,
perr.err->message);
if (showed_dialog != NULL)
*showed_dialog = TRUE;
parse_error_free (&perr);
if (reedit == GNM_VALIDATION_STATUS_INVALID_EDIT) {
range_fragment_free (selection);
return FALSE;
}
/* restore focus to sheet , or we'll leave edit
* mode only to jump right back in the new
* cell because it looks like someone just
* focused on the edit line (eg hit F2) */
wbcg_focus_cur_scg (wbcg);
}
if (texpr_test != NULL)
gnm_expr_top_unref (texpr_test);
}
/* We only enter an array formula if the text is a formula */
if (result == WBC_EDIT_ACCEPT_ARRAY && !expr_txt)
result = WBC_EDIT_ACCEPT_RANGE;
if (result == WBC_EDIT_ACCEPT_ARRAY) {
GnmParsePos pp_array;
GnmRange *r = selection->data;
parse_pos_init (&pp_array, sheet->workbook, sheet, r->start.col, r->start.row);
if ((texpr = gnm_expr_parse_str
(expr_txt, &pp_array, GNM_EXPR_PARSE_DEFAULT,
sheet_get_conventions (sheet), NULL)) == NULL)
result = WBC_EDIT_ACCEPT_RANGE;
}
/* We need to save the information that we will temporarily overwrite */
/* We then assign the information. No need to worry about formatting */
/* Finally we can check the validation! */
switch (result) {
case (WBC_EDIT_ACCEPT_RANGE): {
GSList *l;
for (l = selection; l != NULL; l = l->next) {
GnmRange *r = l->data;
u = go_undo_combine (u, clipboard_copy_range_undo (sheet, r));
}
for (l = selection; l != NULL; l = l->next) {
GnmRange *r = l->data;
/* We do this separately since there may be overlap between ranges */
sheet_range_set_text (&pp, r, txt);
valid = gnm_validation_eval_range (wbc, sheet, &sv->edit_pos, r,
showed_dialog);
if (valid != GNM_VALIDATION_STATUS_VALID)
break;
}
break;
}
case (WBC_EDIT_ACCEPT_ARRAY): {
GnmRange *r = selection->data;
u = go_undo_combine (u, clipboard_copy_range_undo (sheet, r));
if (texpr) {
gnm_expr_top_ref (texpr);
gnm_cell_set_array_formula (sheet,
r->start.col, r->start.row,
r->end.col, r->end.row,
texpr);
sheet_region_queue_recalc (sheet, r);
}
valid = gnm_validation_eval_range (wbc, sheet, &sv->edit_pos, r,
showed_dialog);
break;
}
case (WBC_EDIT_ACCEPT_WO_AC):
case (WBC_EDIT_ACCEPT): {
GnmRange r;
GnmCell *cell;
range_init_cellpos (&r, &sv->edit_pos);
u = clipboard_copy_range_undo (sheet, &r);
cell = sheet_cell_fetch (sheet,
sv->edit_pos.col,
sv->edit_pos.row);
sheet_cell_set_text (cell, txt, wbcg->edit_line.markup);
valid = gnm_validation_eval (wbc, mstyle, sheet, &sv->edit_pos, showed_dialog);
break;
}
case (WBC_EDIT_REJECT):
default:
/* We should not be able to get here! */
break;
}
range_fragment_free (selection);
/* We need to rebuild the original info first. */
go_undo_undo (u);
g_object_unref (u);
/* Now we can respond to our validation information */
if (valid != GNM_VALIDATION_STATUS_VALID) {
result = WBC_EDIT_REJECT;
if (valid == GNM_VALIDATION_STATUS_INVALID_EDIT) {
gtk_window_set_focus (wbcg_toplevel (wbcg),
(GtkWidget *) wbcg_get_entry (wbcg));
g_free (free_txt);
if (texpr != NULL)
gnm_expr_top_unref (texpr);
return FALSE;
}
} else {
if (result == WBC_EDIT_ACCEPT_ARRAY) {
cmd_area_set_array_expr (wbc, sv, texpr);
} else {
PangoAttrList *res_markup = wbcg->edit_line.markup
? pango_attr_list_copy (wbcg->edit_line.markup)
: NULL;
if (result == WBC_EDIT_ACCEPT)
cmd_set_text (wbc, sheet, &sv->edit_pos, txt, res_markup, TRUE);
else if (result == WBC_EDIT_ACCEPT_WO_AC)
cmd_set_text (wbc, sheet, &sv->edit_pos, txt, res_markup, FALSE);
else
cmd_area_set_text (wbc, sv, txt, res_markup);
if (res_markup)
pango_attr_list_unref (res_markup);
}
}
if (texpr != NULL)
gnm_expr_top_unref (texpr);
g_free (free_txt);
} else {
if (sv == wb_control_cur_sheet_view (wbc)) {
/* Redraw the cell contents in case there was a span */
GnmRange tmp; tmp.start = tmp.end = sv->edit_pos;
sheet_range_bounding_box (sv->sheet, &tmp);
sv_redraw_range (wb_control_cur_sheet_view (wbc), &tmp);
}
/* Reload the entry widget with the original contents */
wb_view_edit_line_set (wbv, wbc);
}
/* Stop editing */
wbcg->editing = FALSE;
wbcg->editing_sheet = NULL;
wbcg->editing_cell = NULL;
if (wbcg->edit_line.guru != NULL) {
GtkWidget *w = wbcg->edit_line.guru;
wbc_gtk_detach_guru (wbcg);
gtk_widget_destroy (w);
}
if (wbcg->edit_line.signal_insert) {
g_signal_handler_disconnect (wbcg_get_entry (wbcg),
wbcg->edit_line.signal_insert);
wbcg->edit_line.signal_insert = 0;
}
if (wbcg->edit_line.signal_delete) {
g_signal_handler_disconnect (wbcg_get_entry (wbcg),
wbcg->edit_line.signal_delete);
wbcg->edit_line.signal_delete = 0;
}
if (wbcg->edit_line.signal_cursor_pos) {
g_signal_handler_disconnect (wbcg_get_entry (wbcg),
wbcg->edit_line.signal_cursor_pos);
wbcg->edit_line.signal_cursor_pos = 0;
}
if (wbcg->edit_line.signal_selection_bound) {
g_signal_handler_disconnect (wbcg_get_entry (wbcg),
wbcg->edit_line.signal_selection_bound);
wbcg->edit_line.signal_selection_bound = 0;
}
if (wbcg->edit_line.cell_attrs != NULL) {
pango_attr_list_unref (wbcg->edit_line.cell_attrs);
wbcg->edit_line.cell_attrs = NULL;
}
if (wbcg->edit_line.markup) {
pango_attr_list_unref (wbcg->edit_line.markup);
wbcg->edit_line.markup = NULL;
}
if (wbcg->edit_line.full_content != NULL) {
pango_attr_list_unref (wbcg->edit_line.full_content);
wbcg->edit_line.full_content = NULL;
}
if (wbcg->edit_line.cur_fmt) {
pango_attr_list_unref (wbcg->edit_line.cur_fmt);
wbcg->edit_line.cur_fmt = NULL;
}
/* set pos to 0, to ensure that if we start editing by clicking on the
* editline at the last position, we'll get the right style feedback */
gtk_editable_set_position ((GtkEditable *) wbcg_get_entry (wbcg), 0);
wb_control_update_action_sensitivity (wbc);
if (!sheet->workbook->during_destruction) {
/* restore focus to original sheet in case things were being selected
* on a different page. Do no go through the view, rangesel is
* specific to the control. */
wb_control_sheet_focus (wbc, sheet);
/* Only the edit sheet has an edit cursor */
scg_edit_stop (wbcg_cur_scg (wbcg));
}
wbcg_auto_complete_destroy (wbcg);
wb_control_style_feedback (wbc, NULL); /* in case markup messed with things */
return TRUE;
}
/**
* wbcg_edit_start:
* @wbcg: The workbook to be edited.
* @blankp: If true, erase current cell contents first. If false, leave the
* contents alone.
* @cursorp: If true, create an editing cursor in the current sheet. (If
* false, the text will be editing in the edit box above the sheet,
* but this is not handled by this function.)
*
* Initiate editing of a cell in the sheet. Note that we have two modes of
* editing:
* 1) in-cell editing when you just start typing, and
* 2) above sheet editing when you hit F2.
*
* Returns TRUE if we did indeed start editing. Returns FALSE if the
* cell-to-be-edited was locked.
*/
gboolean
wbcg_edit_start (WBCGtk *wbcg,
gboolean blankp, gboolean cursorp)
{
/* We could save this, but the situation is rare, if confusing. */
static gboolean warn_on_text_format = TRUE;
SheetView *sv;
SheetControlGUI *scg;
GnmCell *cell;
char *text = NULL;
int col, row;
WorkbookView *wbv;
int cursor_pos = -1;
g_return_val_if_fail (GNM_IS_WBC_GTK (wbcg), FALSE);
if (wbcg_is_editing (wbcg))
return TRUE;
/* Avoid recursion, and do not begin editing if a guru is up */
if (wbcg->inside_editing || wbc_gtk_get_guru (wbcg) != NULL)
return TRUE;
wbcg->inside_editing = TRUE;
wbv = wb_control_view (GNM_WBC (wbcg));
sv = wb_control_cur_sheet_view (GNM_WBC (wbcg));
scg = wbcg_cur_scg (wbcg);
col = sv->edit_pos.col;
row = sv->edit_pos.row;
/* don't edit a locked cell */
/* TODO : extend this to disable edits that cannot succeed
* like editing a single cell of an array. I think we have enough
* information if we look at the selection.
*/
if (wb_view_is_protected (wbv, TRUE) &&
gnm_style_get_contents_locked (sheet_style_get (sv->sheet, col, row))) {
char *pos = g_strdup_printf ( _("%s!%s is locked"),
sv->sheet->name_quoted, cell_coord_name (col, row));
go_cmd_context_error_invalid (GO_CMD_CONTEXT (wbcg), pos,
wb_view_is_protected (wbv, FALSE)
? _("Unprotect the workbook to enable editing.")
: _("Unprotect the sheet to enable editing."));
wbcg->inside_editing = FALSE;
g_free (pos);
return FALSE;
}
cell = sheet_cell_get (sv->sheet, col, row);
if (cell &&
warn_on_text_format &&
go_format_is_text (gnm_cell_get_format (cell)) &&
(gnm_cell_has_expr (cell) || !VALUE_IS_STRING (cell->value))) {
gint res; /* Using GtkResponseType would yield a warning on the switch */
GtkWidget *check;
GtkWidget *align;
GtkWidget *d = gnm_message_dialog_create
(wbcg_toplevel (wbcg),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_WARNING,
_("You are about to edit a cell with \"text\" format."),
_("The cell does not currently contain text, though, so if "
"you go on editing then the contents will be turned into "
"text."));
gtk_dialog_add_button (GTK_DIALOG (d), GTK_STOCK_EDIT, GTK_RESPONSE_OK);
go_gtk_dialog_add_button
(GTK_DIALOG (d), _("Remove format"), GTK_STOCK_REMOVE,
GNM_RESPONSE_REMOVE);
gtk_dialog_add_button (GTK_DIALOG (d), GNM_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
gtk_dialog_set_default_response (GTK_DIALOG (d), GTK_RESPONSE_CANCEL);
check = gtk_check_button_new_with_label (_("Show this dialog next time."));
g_signal_connect (check, "toggled", G_CALLBACK (cb_warn_toggled), &warn_on_text_format);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
align = gtk_alignment_new (0.5, 0.5, 0, 0);
gtk_container_add (GTK_CONTAINER (align), check);
gtk_widget_show_all (align);
gtk_box_pack_end (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (d))), align, TRUE, TRUE, 0);
res = go_gtk_dialog_run (GTK_DIALOG (d), wbcg_toplevel (wbcg));
switch (res) {
case GNM_RESPONSE_REMOVE: {
GnmStyle *style = gnm_style_new ();
gnm_style_set_format (style, go_format_general ());
if (!cmd_selection_format (GNM_WBC (wbcg),
style, NULL, NULL))
break;
/* Fall through. */
}
default:
case GTK_RESPONSE_CANCEL:
wbcg->inside_editing = FALSE;
return FALSE;
case GTK_RESPONSE_OK:
break;
}
}
gnm_app_clipboard_unant ();
if (blankp)
gtk_entry_set_text (wbcg_get_entry (wbcg), "");
else if (cell != NULL) {
gboolean quoted = FALSE;
text = gnm_cell_get_text_for_editing (cell, sv->sheet, "ed, &cursor_pos);
if (text)
gtk_entry_set_text (wbcg_get_entry (wbcg), text);
if (cell->value != NULL) {
GOFormat const *fmt = VALUE_FMT (cell->value);
if (fmt != NULL && go_format_is_markup (fmt)) {
PangoAttrList *markup =
pango_attr_list_copy ((PangoAttrList *)go_format_get_markup (fmt));
if (quoted)
go_pango_attr_list_open_hole (markup, 0, 1);
wbcg_edit_init_markup (wbcg, markup);
}
}
}
gnm_expr_entry_set_scg (wbcg->edit_line.entry, scg);
gnm_expr_entry_set_flags (wbcg->edit_line.entry,
GNM_EE_SHEET_OPTIONAL | GNM_EE_FORMULA_ONLY,
GNM_EE_SINGLE_RANGE | GNM_EE_SHEET_OPTIONAL | GNM_EE_FORMULA_ONLY | GNM_EE_FORCE_REL_REF | GNM_EE_FORCE_ABS_REF);
scg_edit_start (scg);
/* Redraw the cell contents in case there was a span */
sheet_redraw_region (sv->sheet, col, row, col, row);
if (cursorp && /* autocompletion code will not work in the edit line */
wbv->do_auto_completion &&
(text == NULL || g_unichar_isalpha (g_utf8_get_char (text)))) {
wbcg->auto_complete = gnm_complete_sheet_new (
sv->sheet, col, row,
workbook_edit_complete_notify, wbcg);
wbcg->auto_completing = TRUE;
wbcg->auto_max_size = 0;
} else
wbcg->auto_complete = NULL;
/* Give the focus to the edit line */
if (!cursorp)
gtk_window_set_focus (wbcg_toplevel (wbcg),
(GtkWidget *) wbcg_get_entry (wbcg));
wbcg->editing = TRUE;
wbcg->editing_sheet = sv->sheet;
wbcg->editing_cell = cell;
/* If this assert fails, it means editing was not shut down
* properly before
*/
g_return_val_if_fail (wbcg->edit_line.signal_changed == 0, TRUE);
wbcg->edit_line.signal_changed = g_signal_connect (
G_OBJECT (wbcg_get_entry (wbcg)),
"changed",
G_CALLBACK (cb_entry_changed), wbcg);
wbcg->edit_line.signal_insert = g_signal_connect (
G_OBJECT (wbcg_get_entry (wbcg)),
"insert-text",
G_CALLBACK (cb_entry_insert_text), wbcg);
wbcg->edit_line.signal_delete = g_signal_connect (
G_OBJECT (wbcg_get_entry (wbcg)),
"delete-text",
G_CALLBACK (cb_entry_delete_text), wbcg);
wbcg->edit_line.signal_cursor_pos = g_signal_connect_swapped (
G_OBJECT (wbcg_get_entry (wbcg)),
"notify::cursor-position",
G_CALLBACK (cb_entry_cursor_pos), wbcg);
wbcg->edit_line.signal_selection_bound = g_signal_connect_swapped (
G_OBJECT (wbcg_get_entry (wbcg)),
"notify::selection-bound",
G_CALLBACK (cb_entry_cursor_pos), wbcg);
g_free (text);
wb_control_update_action_sensitivity (GNM_WBC (wbcg));
wbcg->inside_editing = FALSE;
gtk_editable_set_position (GTK_EDITABLE (wbcg_get_entry (wbcg)), cursor_pos);
return TRUE;
}
/**
* 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);
}
