/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ /* vim: set sw=8: */ /* * dialog-define-name.c: Edit named regions. * * Author: * Jody Goldberg * Michael Meeks * Chema Celorio * Andreas J. Guelzow * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include #include #include #include "dialogs.h" #include "help.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define DEFINE_NAMES_KEY "define-names-dialog" #define PASTE_NAMES_KEY "paste-names-dialog" typedef struct { GtkBuilder *gui; GtkWidget *dialog; GtkWidget *treeview; GtkTreeStore *model; GtkTreeModel *model_f; GtkWidget *close_button; GtkWidget *paste_button; GtkWidget *search_entry; Sheet *sheet; SheetView *sv; Workbook *wb; WBCGtk *wbcg; GnmParsePos pp; GdkPixbuf *image_add; GdkPixbuf *image_delete; GdkPixbuf *image_lock; GdkPixbuf *image_up; GdkPixbuf *image_down; GdkPixbuf *image_paste; gboolean is_paste_dialog; gboolean has_pasted; } NameGuruState; enum { ITEM_NAME, ITEM_NAME_POINTER, ITEM_CONTENT, ITEM_TYPE, ITEM_CONTENT_IS_EDITABLE, ITEM_NAME_IS_EDITABLE, ITEM_UPDOWN_IMAGE, ITEM_ADDDELETE_IMAGE, ITEM_UPDOWN_ACTIVE, ITEM_ADDDELETE_ACTIVE, ITEM_PASTABLE, ITEM_PASTE_IMAGE, ITEM_VISIBLE, NUM_COLMNS }; typedef enum { item_type_workbook = 0, item_type_main_sheet, item_type_other_sheet, item_type_locked_name, item_type_available_wb_name, item_type_available_sheet_name, item_type_foreign_name, item_type_new_unsaved_wb_name, item_type_new_unsaved_sheet_name, } item_type_t; /** * name_guru_translate_pathstring_to_iter: * @state: * @path_string: in the filter_model * @iter: in the base model * **/ static gboolean name_guru_translate_pathstring_to_iter (NameGuruState *state, GtkTreeIter *iter, gchar const *path_string) { GtkTreeIter iter_f; if (!gtk_tree_model_get_iter_from_string (state->model_f, &iter_f, path_string)) return FALSE; gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (state->model_f), iter, &iter_f); return TRUE; } /** * name_guru_expand_at_iter: * @state: * @iter: * * expand the treeview at the given iter. * **/ static void name_guru_expand_at_iter (NameGuruState *state, GtkTreeIter *iter) { GtkTreePath *path; path = gtk_tree_model_get_path (GTK_TREE_MODEL (state->model), iter); gtk_tree_view_expand_to_path (GTK_TREE_VIEW (state->treeview), path); gtk_tree_path_free (path); } /** * name_guru_warned_if_used: * @state: * @nexpr: expression to be deleted * * If the expresion that is about to be deleted is being used, * warn the user about it. Ask if we should proceed or not * * Return Value: TRUE if users confirms deletion, FALSE otherwise **/ static gboolean name_guru_warn (NameGuruState *state, GnmNamedExpr *nexpr) { return (!expr_name_in_use (nexpr) || go_gtk_query_yes_no (GTK_WINDOW (state->dialog), FALSE, "The defined name '%s' is in use. " "Do you really want to delete it?", expr_name_name (nexpr))); } static gboolean cb_name_guru_show_all (G_GNUC_UNUSED GtkTreeModel *model, G_GNUC_UNUSED GtkTreePath *path, GtkTreeIter *iter, gpointer data) { NameGuruState *state = data; gtk_tree_store_set (state->model, iter, ITEM_VISIBLE, TRUE, -1); return FALSE; } static void name_guru_erase_search_entry (GtkEntry *entry, G_GNUC_UNUSED GtkEntryIconPosition icon_pos, G_GNUC_UNUSED GdkEvent *event, gpointer data) { NameGuruState *state = data; gtk_entry_set_text (entry, ""); gtk_tree_model_foreach (GTK_TREE_MODEL (state->model), cb_name_guru_show_all, state); } static gboolean cb_name_guru_search (GtkTreeModel *model, G_GNUC_UNUSED GtkTreePath *path, GtkTreeIter *iter, gpointer data) { char const *text = data; gchar *name; gboolean visible = TRUE, was_visible; item_type_t type; gtk_tree_model_get (model, iter, ITEM_TYPE, &type, ITEM_NAME, &name, ITEM_VISIBLE, &was_visible, -1); if (type != item_type_workbook && type != item_type_main_sheet && type != item_type_other_sheet) { gchar *name_n, *name_cf, *text_n, *text_cf; text_n = g_utf8_normalize (text, -1, G_NORMALIZE_ALL); text_cf = g_utf8_casefold(text_n, -1); name_n = g_utf8_normalize (name, -1, G_NORMALIZE_ALL); name_cf = g_utf8_casefold(name_n, -1); visible = (NULL != g_strstr_len (name_cf, -1, text_cf)); g_free (text_n); g_free (text_cf); g_free (name_n); g_free (name_cf); } if (visible != was_visible) gtk_tree_store_set (GTK_TREE_STORE (model), iter, ITEM_VISIBLE, visible, -1); g_free (name); return FALSE; } static void name_guru_search (GtkEntry *entry, gpointer data) { gchar const *text; NameGuruState *state = data; if (0 == gtk_entry_get_text_length (entry)){ name_guru_erase_search_entry (entry, GTK_ENTRY_ICON_SECONDARY, NULL, data); return; } text = gtk_entry_get_text (entry); gtk_tree_model_foreach (GTK_TREE_MODEL (state->model), cb_name_guru_search, (gpointer) text); } static void cb_get_names (G_GNUC_UNUSED gpointer key, GnmNamedExpr *nexpr, GList **accum) { if (!nexpr->is_hidden) *accum = g_list_prepend (*accum, nexpr); } static GList * name_guru_get_available_sheet_names (Sheet const *sheet) { GList *res = NULL; gnm_sheet_foreach_name (sheet, (GHFunc) cb_get_names, &res); return g_list_sort (res, (GCompareFunc)expr_name_cmp_by_name); } static GList * name_guru_get_available_wb_names (Workbook const *wb) { GList *res = NULL; workbook_foreach_name (wb, TRUE, (GHFunc) cb_get_names, &res); return g_list_sort (res, (GCompareFunc)expr_name_cmp_by_name); } static void name_guru_set_images (NameGuruState *state, GtkTreeIter *name_iter, item_type_t type, gboolean pastable) { GdkPixbuf *button1 = NULL, *button2 = NULL; switch (type) { case item_type_workbook: case item_type_main_sheet: button2 = state->image_add; break; case item_type_locked_name: button2 = state->image_lock; break; case item_type_available_wb_name: case item_type_new_unsaved_wb_name: button1 = state->image_down; button2 = state->image_delete; break; case item_type_available_sheet_name: case item_type_new_unsaved_sheet_name: button1 = state->image_up; button2 = state->image_delete; break; case item_type_other_sheet: case item_type_foreign_name: default: break; } gtk_tree_store_set (state->model, name_iter, ITEM_UPDOWN_IMAGE, button1, ITEM_ADDDELETE_IMAGE, button2, ITEM_PASTE_IMAGE, pastable ? state->image_paste : NULL, ITEM_UPDOWN_ACTIVE, button1 != NULL, ITEM_ADDDELETE_ACTIVE, button2 != NULL, -1); } static void name_guru_store_names (GList *list, GtkTreeIter *iter, NameGuruState *state, item_type_t type) { GtkTreeIter name_iter; char *content; item_type_t adj_type; GList *l; for (l = list; l != NULL; l = l->next) { GnmNamedExpr *nexpr = l->data; gboolean ciseditable, ispastable; if (nexpr->is_hidden || expr_name_is_placeholder (nexpr)) continue; ispastable = ciseditable = type == item_type_available_wb_name || type == item_type_available_sheet_name; if (nexpr->is_permanent) { adj_type = item_type_locked_name; ciseditable = FALSE; } else adj_type = type; content = expr_name_as_string (nexpr, &state->pp, sheet_get_conventions (state->sheet)); gtk_tree_store_append (state->model, &name_iter, iter); gtk_tree_store_set (state->model, &name_iter, ITEM_NAME, expr_name_name (nexpr), ITEM_NAME_POINTER, nexpr, ITEM_CONTENT, content, ITEM_TYPE, adj_type, ITEM_CONTENT_IS_EDITABLE, ciseditable, ITEM_NAME_IS_EDITABLE, FALSE, ITEM_PASTABLE, ispastable, ITEM_VISIBLE, TRUE, -1); g_free (content); name_guru_set_images (state, &name_iter, adj_type, ispastable); } g_list_free (list); } static void name_guru_populate_list (NameGuruState *state) { GtkTreeIter iter; g_return_if_fail (state != NULL); g_return_if_fail (state->treeview != NULL); gtk_tree_store_clear (state->model); gtk_tree_store_append (state->model, &iter, NULL); gtk_tree_store_set (state->model, &iter, ITEM_NAME, _("Workbook"), ITEM_NAME_POINTER, NULL, ITEM_TYPE, item_type_workbook, ITEM_CONTENT_IS_EDITABLE, FALSE, ITEM_NAME_IS_EDITABLE, FALSE, ITEM_PASTABLE, FALSE, ITEM_VISIBLE, TRUE, -1); name_guru_set_images (state, &iter, item_type_workbook, FALSE); name_guru_store_names (name_guru_get_available_wb_names (state->wb), &iter, state, item_type_available_wb_name); name_guru_expand_at_iter (state, &iter); gtk_tree_store_append (state->model, &iter, NULL); gtk_tree_store_set (state->model, &iter, ITEM_NAME, state->sheet->name_unquoted, ITEM_NAME_POINTER, state->sheet, ITEM_TYPE, item_type_main_sheet, ITEM_CONTENT_IS_EDITABLE, FALSE, ITEM_NAME_IS_EDITABLE, FALSE, ITEM_PASTABLE, FALSE, ITEM_VISIBLE, TRUE, -1); name_guru_set_images (state, &iter, item_type_main_sheet, FALSE); name_guru_store_names (name_guru_get_available_sheet_names (state->sheet), &iter, state, item_type_available_sheet_name); name_guru_expand_at_iter (state, &iter); WORKBOOK_FOREACH_SHEET (state->wb, sheet, { if (sheet == state->sheet) continue; gtk_tree_store_append (state->model, &iter, NULL); gtk_tree_store_set (state->model, &iter, ITEM_NAME, sheet->name_unquoted, ITEM_NAME_POINTER, sheet, ITEM_TYPE, item_type_other_sheet, ITEM_CONTENT_IS_EDITABLE, FALSE, ITEM_NAME_IS_EDITABLE, FALSE, ITEM_VISIBLE, TRUE, ITEM_PASTABLE, FALSE, -1); name_guru_store_names (name_guru_get_available_sheet_names (sheet), &iter, state, item_type_foreign_name); }); } static gboolean name_guru_paste (NameGuruState *state, GtkTreeIter *iter) { char *name; gboolean is_pastable; gtk_tree_model_get (GTK_TREE_MODEL (state->model), iter, ITEM_PASTABLE, &is_pastable, ITEM_NAME, &name, -1); if (!is_pastable) return FALSE; if (wbcg_edit_start (state->wbcg, FALSE, FALSE)) { GtkEntry *entry; gint position; entry = wbcg_get_entry (state->wbcg); position = gtk_entry_get_text_length (entry); if (position == 0) gtk_editable_insert_text (GTK_EDITABLE (entry), "=", -1, &position); else { gtk_editable_delete_selection (GTK_EDITABLE (entry)); position = gtk_editable_get_position (GTK_EDITABLE (entry)); } if (state->has_pasted) { char sep = go_locale_get_arg_sep (); gtk_editable_insert_text (GTK_EDITABLE (entry), &sep, 1, &position); } gtk_editable_insert_text (GTK_EDITABLE (entry), name, -1, &position); gtk_editable_set_position (GTK_EDITABLE (entry), position); } g_free (name); state->has_pasted = TRUE; return TRUE; } static void cb_name_guru_clicked (GtkWidget *button, NameGuruState *state) { if (state->dialog == NULL) return; wbcg_set_entry (state->wbcg, NULL); if (button == state->close_button) { gtk_widget_destroy (state->dialog); return; } if (button == state->paste_button) { GtkTreeIter iter_f; GtkTreeIter iter; if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (state->treeview)), NULL, &iter_f)) { gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (state->model_f), &iter, &iter_f); if (name_guru_paste (state, &iter)) gtk_widget_destroy (state->dialog); } return; } } static GtkWidget * name_guru_init_button (NameGuruState *state, char const *name) { GtkWidget *tmp = go_gtk_builder_get_widget (state->gui, name); g_return_val_if_fail (tmp != NULL, NULL); g_signal_connect (G_OBJECT (tmp), "clicked", G_CALLBACK (cb_name_guru_clicked), state); return tmp; } static void cb_name_guru_destroy (NameGuruState *state) { WorkbookControl *wbc = WORKBOOK_CONTROL (state->wbcg); wb_view_selection_desc (wb_control_view (wbc), TRUE, wbc); if (state->gui != NULL) { g_object_unref (state->gui); state->gui = NULL; } if (state->is_paste_dialog) g_object_unref (state->image_paste); else { wbcg_edit_finish (state->wbcg, WBC_EDIT_REJECT, NULL); g_object_unref (state->image_add); g_object_unref (state->image_delete); g_object_unref (state->image_lock); g_object_unref (state->image_up); g_object_unref (state->image_down); } state->dialog = NULL; g_free (state); } static void cb_name_guru_paste (G_GNUC_UNUSED GtkCellRendererToggle *cell, gchar *path_string, gpointer data) { NameGuruState *state = data; GtkTreeIter iter; if (name_guru_translate_pathstring_to_iter (state, &iter, path_string)) name_guru_paste (state, &iter); } static void name_guru_add (NameGuruState *state, GtkTreeIter *iter, gchar const *path_string) { GtkTreeIter name_iter; char *content; GtkTreePath *path; item_type_t type; path = gtk_tree_path_new_from_string (path_string); type = ((gtk_tree_path_get_indices (path))[0] == 0) ? item_type_new_unsaved_wb_name : item_type_new_unsaved_sheet_name; content = selection_to_string (state->sv, FALSE); gtk_tree_store_insert (state->model, &name_iter, iter, 0); gtk_tree_store_set (state->model, &name_iter, ITEM_NAME, _(""), ITEM_NAME_POINTER, NULL, ITEM_CONTENT, ((content == NULL) ? "#REF!" : content), ITEM_TYPE, type, ITEM_CONTENT_IS_EDITABLE, TRUE, ITEM_NAME_IS_EDITABLE, TRUE, ITEM_PASTABLE, FALSE, ITEM_VISIBLE, TRUE, -1); name_guru_set_images (state, &name_iter, type, FALSE); name_guru_expand_at_iter (state, iter); g_free (content); } static void name_guru_delete (NameGuruState *state, GtkTreeIter *iter, item_type_t type) { GnmNamedExpr *nexpr; if (type != item_type_new_unsaved_wb_name && type != item_type_new_unsaved_sheet_name) { gtk_tree_model_get (GTK_TREE_MODEL (state->model), iter, ITEM_NAME_POINTER, &nexpr, -1); if (!name_guru_warn (state, nexpr)) return; cmd_remove_name (WORKBOOK_CONTROL (state->wbcg), nexpr); } gtk_tree_store_remove (state->model, iter); } static void cb_name_guru_add_delete (G_GNUC_UNUSED GtkCellRendererToggle *cell, gchar *path_string, gpointer data) { NameGuruState *state = data; GtkTreeIter iter; if (name_guru_translate_pathstring_to_iter (state, &iter, path_string)) { item_type_t type; gtk_tree_model_get (GTK_TREE_MODEL (state->model), &iter, ITEM_TYPE, &type, -1); switch (type) { case item_type_workbook: case item_type_main_sheet: name_guru_add (state, &iter, path_string); break; case item_type_available_wb_name: case item_type_available_sheet_name: case item_type_new_unsaved_wb_name: case item_type_new_unsaved_sheet_name: name_guru_delete (state, &iter, type); break; case item_type_other_sheet: case item_type_locked_name: case item_type_foreign_name: default: break; } } } static void name_guru_find_place (NameGuruState *state, GtkTreeIter *iter, GtkTreeIter *parent_iter, GnmNamedExpr *nexpr) { GtkTreeIter next_iter; GnmNamedExpr *next_nexpr; if (nexpr != NULL && gtk_tree_model_iter_children (GTK_TREE_MODEL (state->model), &next_iter, parent_iter)) { do { gtk_tree_model_get (GTK_TREE_MODEL (state->model), &next_iter, ITEM_NAME_POINTER, &next_nexpr, -1); if (next_nexpr != NULL && expr_name_cmp_by_name (nexpr, next_nexpr) < 0) { gtk_tree_store_insert_before (state->model, iter, parent_iter, &next_iter); return; } } while (gtk_tree_model_iter_next (GTK_TREE_MODEL (state->model), &next_iter)); gtk_tree_store_append (state->model, iter, parent_iter); } else { gtk_tree_store_prepend (state->model, iter, parent_iter); } } static void name_guru_move_record (NameGuruState *state, GtkTreeIter *from_iter, GtkTreeIter *new_parent_iter, item_type_t new_type) { GnmNamedExpr *nexpr; gchar *name, *content; gboolean ceditable, neditable, pastable, visible; GtkTreeIter new_iter; gtk_tree_model_get (GTK_TREE_MODEL (state->model), from_iter, ITEM_NAME, &name, ITEM_NAME_POINTER, &nexpr, ITEM_CONTENT, &content, ITEM_CONTENT_IS_EDITABLE, &ceditable, ITEM_NAME_IS_EDITABLE, &neditable, ITEM_PASTABLE, &pastable, ITEM_VISIBLE, &visible, -1); gtk_tree_store_remove (state->model, from_iter); name_guru_find_place (state, &new_iter, new_parent_iter, nexpr); gtk_tree_store_set (state->model, &new_iter, ITEM_NAME, name, ITEM_NAME_POINTER, nexpr, ITEM_CONTENT, content, ITEM_TYPE, new_type, ITEM_CONTENT_IS_EDITABLE, ceditable, ITEM_NAME_IS_EDITABLE, neditable, ITEM_PASTABLE, pastable, ITEM_VISIBLE, visible, -1); name_guru_set_images (state, &new_iter, new_type, pastable); name_guru_expand_at_iter (state, &new_iter); g_free (name); g_free (content); } static void cb_name_guru_switch_scope (G_GNUC_UNUSED GtkCellRendererToggle *cell, gchar *path_string, gpointer data) { NameGuruState *state = data; GtkTreeIter iter; if (name_guru_translate_pathstring_to_iter (state, &iter, path_string)) { item_type_t type, new_type; gchar const *new_path; GnmNamedExpr *nexpr; GtkTreeIter new_parent_iter; gtk_tree_model_get (GTK_TREE_MODEL (state->model), &iter, ITEM_TYPE, &type, ITEM_NAME_POINTER, &nexpr, -1); switch (type) { case item_type_available_wb_name: if (cmd_rescope_name (WORKBOOK_CONTROL (state->wbcg), nexpr, state->sheet)) return; new_path = "1"; new_type = item_type_available_sheet_name; break; case item_type_new_unsaved_wb_name: new_path = "1"; new_type = item_type_new_unsaved_sheet_name; break; case item_type_available_sheet_name: if (cmd_rescope_name (WORKBOOK_CONTROL (state->wbcg), nexpr, NULL)) return; new_path = "0"; new_type = item_type_available_wb_name; break; case item_type_new_unsaved_sheet_name: new_path = "0"; new_type = item_type_new_unsaved_wb_name; break; case item_type_workbook: case item_type_main_sheet: case item_type_other_sheet: case item_type_locked_name: case item_type_foreign_name: default: return; } if (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (state->model), &new_parent_iter, new_path)) { name_guru_move_record (state, &iter, &new_parent_iter, new_type); } } } static gboolean name_guru_parse_pos_init (NameGuruState *state, GnmParsePos *pp, item_type_t type) { switch (type) { case item_type_available_wb_name: case item_type_new_unsaved_wb_name: parse_pos_init (pp, state->wb, NULL, state->pp.eval.col, state->pp.eval.row); return TRUE; case item_type_available_sheet_name: case item_type_new_unsaved_sheet_name: parse_pos_init (pp, state->wb, state->sheet, state->pp.eval.col, state->pp.eval.row); return TRUE; case item_type_workbook: case item_type_main_sheet: case item_type_other_sheet: case item_type_locked_name: case item_type_foreign_name: default: return FALSE; } } /* * Return the expression if it is acceptable. * The parse position will be initialized then. */ static GnmExprTop const* name_guru_check_expression (NameGuruState *state, gchar *text, GnmParsePos *pp, item_type_t type) { GnmExprTop const *texpr; GnmParseError perr; if (!name_guru_parse_pos_init (state, pp, type)) return NULL; /* We should have never gotten here. */ if (text == NULL || text[0] == '\0') { go_gtk_notice_dialog (GTK_WINDOW (state->dialog), GTK_MESSAGE_ERROR, _("Why would you want to define a " "name for the empty string?")); return NULL; } texpr = gnm_expr_parse_str (text, pp, GNM_EXPR_PARSE_DEFAULT | GNM_EXPR_PARSE_UNKNOWN_NAMES_ARE_INVALID | GNM_EXPR_PARSE_PERMIT_MULTIPLE_EXPRESSIONS, NULL, parse_error_init (&perr)); if (texpr == NULL) { if (perr.err == NULL) return NULL; go_gtk_notice_dialog (GTK_WINDOW (state->dialog), GTK_MESSAGE_ERROR, "%s", perr.err->message); parse_error_free (&perr); return NULL; } /* don't allow user to define a nexpr that looks like a placeholder * * because it will be would disappear from the lists. */ if (gnm_expr_top_is_err (texpr, GNM_ERROR_NAME)) { go_gtk_notice_dialog (GTK_WINDOW (state->dialog), GTK_MESSAGE_ERROR, _("Why would you want to define a name to be #NAME?")); parse_error_free (&perr); gnm_expr_top_unref (texpr); return NULL; } return texpr; } static void cb_name_guru_content_edited (G_GNUC_UNUSED GnumericCellRendererExprEntry *cell, gchar *path_string, gchar *new_text, NameGuruState *state) { GtkTreeIter iter; item_type_t type; GnmParsePos pp; GnmExprTop const *texpr; GnmNamedExpr *nexpr; if (!name_guru_translate_pathstring_to_iter (state, &iter, path_string)) return; gtk_tree_model_get (GTK_TREE_MODEL (state->model), &iter, ITEM_TYPE, &type, ITEM_NAME_POINTER, &nexpr, -1); /* check whether the content is valid */ texpr = name_guru_check_expression (state, new_text, &pp , type); if (texpr == NULL) return; /* content is valid */ if (type != item_type_new_unsaved_wb_name && type != item_type_new_unsaved_sheet_name) { /* save the changes (if the name is already saved) */ cmd_define_name (WORKBOOK_CONTROL (state->wbcg), expr_name_name (nexpr), &pp, texpr, NULL); } else gnm_expr_top_unref (texpr); /* set the model */ gtk_tree_store_set (state->model, &iter, ITEM_CONTENT, new_text, -1); } static void cb_name_guru_name_edited (G_GNUC_UNUSED GtkCellRendererText *cell, gchar *path_string, gchar *new_text, NameGuruState *state) { GtkTreeIter iter; GtkTreeIter parent_iter; item_type_t type; GnmParsePos pp; GnmExprTop const *texpr; gchar *content; GnmNamedExpr *nexpr; g_return_if_fail (new_text != NULL); if (!name_guru_translate_pathstring_to_iter (state, &iter, path_string)) return; gtk_tree_model_get (GTK_TREE_MODEL (state->model), &iter, ITEM_TYPE, &type, ITEM_CONTENT, &content, -1); if (type != item_type_new_unsaved_wb_name && type != item_type_new_unsaved_sheet_name) return; name_guru_parse_pos_init (state, &pp, type); nexpr = expr_name_lookup (&pp, new_text); if (nexpr != NULL && !nexpr->is_placeholder) { Sheet *scope = nexpr->pos.sheet; if ((type == item_type_new_unsaved_wb_name && scope == NULL) || (type == item_type_new_unsaved_sheet_name)) { go_gtk_notice_dialog (GTK_WINDOW (state->dialog), GTK_MESSAGE_ERROR, _("This name is already in use!")); return; } } texpr = name_guru_check_expression (state, content, &pp , type); if (texpr == NULL) return; if (!cmd_define_name (WORKBOOK_CONTROL (state->wbcg), new_text, &pp, texpr, NULL)) { nexpr = expr_name_lookup (&pp, new_text); type = (type == item_type_new_unsaved_wb_name) ? item_type_available_wb_name : item_type_available_sheet_name; gtk_tree_store_set (state->model, &iter, ITEM_NAME, new_text, ITEM_NAME_POINTER, nexpr, ITEM_TYPE, type, ITEM_PASTABLE, TRUE, ITEM_NAME_IS_EDITABLE, FALSE, -1); name_guru_set_images (state, &iter, type, TRUE); if (gtk_tree_model_iter_parent (GTK_TREE_MODEL (state->model), &parent_iter, &iter)) name_guru_move_record (state, &iter, &parent_iter, type); } } static void name_guru_update_sensitivity (GtkTreeSelection *treeselection, gpointer user_data) { NameGuruState *state = user_data; gboolean is_pastable = FALSE; GtkTreeIter iter; if (gtk_tree_selection_get_selected (treeselection, NULL, &iter)) gtk_tree_model_get (state->model_f, &iter, ITEM_PASTABLE, &is_pastable, -1); gtk_widget_set_sensitive (GTK_WIDGET (state->paste_button), is_pastable); } static gboolean cb_name_guru_selection_function (G_GNUC_UNUSED GtkTreeSelection *selection, GtkTreeModel *model, GtkTreePath *path, gboolean path_currently_selected, G_GNUC_UNUSED gpointer data) { GtkTreeIter iter; if (path_currently_selected) return TRUE; if (gtk_tree_model_get_iter (model, &iter, path)) { gboolean is_pastable, is_editable; gtk_tree_model_get (model, &iter, ITEM_PASTABLE, &is_pastable, ITEM_CONTENT_IS_EDITABLE, &is_editable, -1); return (is_pastable || is_editable); } return FALSE; } static gboolean name_guru_init (NameGuruState *state, WBCGtk *wbcg, gboolean is_paste_dialog) { Workbook *wb = wb_control_get_workbook (WORKBOOK_CONTROL (wbcg)); GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkTreeSelection *selection; state->is_paste_dialog = is_paste_dialog; state->has_pasted = FALSE; state->gui = gnm_gtk_builder_load ("define-name.ui", NULL, GO_CMD_CONTEXT (wbcg)); if (state->gui == NULL) return TRUE; state->wbcg = wbcg; state->wb = wb; state->sv = wb_control_cur_sheet_view (WORKBOOK_CONTROL (wbcg)); state->sheet = sv_sheet (state->sv); parse_pos_init_editpos (&state->pp, state->sv); state->dialog = go_gtk_builder_get_widget (state->gui, "NameGuru"); gnm_dialog_setup_destroy_handlers (GTK_DIALOG (state->dialog), state->wbcg, GNM_DIALOG_DESTROY_SHEET_REMOVED); state->model = gtk_tree_store_new (NUM_COLMNS, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_STRING, G_TYPE_INT, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, GDK_TYPE_PIXBUF, GDK_TYPE_PIXBUF, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, GDK_TYPE_PIXBUF, G_TYPE_BOOLEAN); state->treeview = go_gtk_builder_get_widget (state->gui, "name_list"); state->model_f = gtk_tree_model_filter_new (GTK_TREE_MODEL (state->model), NULL); gtk_tree_model_filter_set_visible_column (GTK_TREE_MODEL_FILTER (state->model_f), ITEM_VISIBLE); gtk_tree_view_set_model (GTK_TREE_VIEW (state->treeview), state->model_f); g_object_unref (state->model_f); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (state->treeview), FALSE); gtk_tree_view_set_grid_lines (GTK_TREE_VIEW (state->treeview), GTK_TREE_VIEW_GRID_LINES_NONE); gtk_tree_view_set_reorderable (GTK_TREE_VIEW (state->treeview), FALSE); renderer = gtk_cell_renderer_text_new (); g_signal_connect (G_OBJECT (renderer), "edited", G_CALLBACK (cb_name_guru_name_edited), state); column = gtk_tree_view_column_new_with_attributes ("name", renderer, "text", ITEM_NAME, "editable", ITEM_NAME_IS_EDITABLE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (state->treeview), column); if (is_paste_dialog) { renderer = gnumeric_cell_renderer_toggle_new (); g_signal_connect (G_OBJECT (renderer), "toggled", G_CALLBACK (cb_name_guru_paste), state); column = gtk_tree_view_column_new_with_attributes ("Paste", renderer, "active", ITEM_PASTABLE, "pixbuf", ITEM_PASTE_IMAGE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (state->treeview), column); } else { renderer = gnumeric_cell_renderer_toggle_new (); g_signal_connect (G_OBJECT (renderer), "toggled", G_CALLBACK (cb_name_guru_add_delete), state); column = gtk_tree_view_column_new_with_attributes ("Lock", renderer, "active", ITEM_ADDDELETE_ACTIVE, "pixbuf", ITEM_ADDDELETE_IMAGE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (state->treeview), column); renderer = gnumeric_cell_renderer_toggle_new (); g_signal_connect (G_OBJECT (renderer), "toggled", G_CALLBACK (cb_name_guru_switch_scope), state); column = gtk_tree_view_column_new_with_attributes ("Scope", renderer, "active", ITEM_UPDOWN_ACTIVE, "pixbuf", ITEM_UPDOWN_IMAGE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (state->treeview), column); } renderer = gnumeric_cell_renderer_expr_entry_new (state->wbcg); g_signal_connect (G_OBJECT (renderer), "edited", G_CALLBACK (cb_name_guru_content_edited), state); column = gtk_tree_view_column_new_with_attributes (_("content"), renderer, "text", ITEM_CONTENT, "editable", ITEM_CONTENT_IS_EDITABLE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (state->treeview), column); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (state->treeview)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE); gtk_tree_selection_set_select_function (selection, cb_name_guru_selection_function, state, NULL); state->close_button = name_guru_init_button (state, "close_button"); state->paste_button = name_guru_init_button (state, "paste_button"); if (is_paste_dialog) { g_signal_connect (G_OBJECT (selection), "changed", G_CALLBACK (name_guru_update_sensitivity), state); state->image_paste = gtk_widget_render_icon_pixbuf (state->dialog, GTK_STOCK_PASTE, GTK_ICON_SIZE_SMALL_TOOLBAR); state->image_add = NULL; state->image_delete = NULL; state->image_lock = NULL; state->image_up = NULL; state->image_down = NULL; } else { state->image_paste = NULL; state->image_add = gtk_widget_render_icon_pixbuf (state->dialog, GTK_STOCK_ADD, GTK_ICON_SIZE_SMALL_TOOLBAR); state->image_delete = gtk_widget_render_icon_pixbuf (state->dialog, GTK_STOCK_REMOVE, GTK_ICON_SIZE_SMALL_TOOLBAR); state->image_lock = gtk_widget_render_icon_pixbuf (state->dialog, "Gnumeric_Protection_Yes", GTK_ICON_SIZE_SMALL_TOOLBAR); state->image_up = gtk_widget_render_icon_pixbuf (state->dialog, GTK_STOCK_GO_UP, GTK_ICON_SIZE_SMALL_TOOLBAR); state->image_down = gtk_widget_render_icon_pixbuf (state->dialog, GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_SMALL_TOOLBAR); } state->search_entry = go_gtk_builder_get_widget (state->gui, "search_entry"); gtk_entry_set_icon_from_stock (GTK_ENTRY (state->search_entry), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR); gtk_entry_set_icon_tooltip_text (GTK_ENTRY (state->search_entry), GTK_ENTRY_ICON_SECONDARY, _("Erase the search entry.")); gtk_entry_set_icon_sensitive (GTK_ENTRY (state->search_entry), GTK_ENTRY_ICON_SECONDARY, TRUE); gtk_entry_set_icon_activatable (GTK_ENTRY (state->search_entry), GTK_ENTRY_ICON_SECONDARY, TRUE); g_signal_connect (G_OBJECT (state->search_entry), "icon-press", G_CALLBACK (name_guru_erase_search_entry), state); g_signal_connect (G_OBJECT (state->search_entry), "activate", G_CALLBACK (name_guru_search), state); name_guru_populate_list (state); name_guru_update_sensitivity (selection, state); gnumeric_init_help_button ( go_gtk_builder_get_widget (state->gui, "help_button"), is_paste_dialog ? GNUMERIC_HELP_LINK_PASTE_NAMES : GNUMERIC_HELP_LINK_DEFINE_NAMES); /* a candidate for merging into attach guru */ gnumeric_keyed_dialog (state->wbcg, GTK_WINDOW (state->dialog), is_paste_dialog ? PASTE_NAMES_KEY : DEFINE_NAMES_KEY); go_gtk_nonmodal_dialog (wbcg_toplevel (state->wbcg), GTK_WINDOW (state->dialog)); g_object_set_data_full (G_OBJECT (state->dialog), "state", state, (GDestroyNotify)cb_name_guru_destroy); if (is_paste_dialog) { gtk_window_set_title (GTK_WINDOW (state->dialog), _("Paste Defined Names")); gtk_widget_show_all (GTK_WIDGET (state->dialog)); } else { wbc_gtk_attach_guru (state->wbcg, state->dialog); gtk_widget_show (GTK_WIDGET (state->dialog)); } return FALSE; } /** * dialog_define_names: * @wbcg: * * Create and show the define names dialog. **/ void dialog_define_names (WBCGtk *wbcg) { NameGuruState *state; g_return_if_fail (wbcg != NULL); /* Only one guru per workbook. */ if (wbc_gtk_get_guru (wbcg)) return; /* Only pop up one copy per workbook */ if (gnumeric_dialog_raise_if_exists (wbcg, DEFINE_NAMES_KEY)) return; state = g_new0 (NameGuruState, 1); if (name_guru_init (state, wbcg, FALSE)) { go_gtk_notice_dialog (wbcg_toplevel (wbcg), GTK_MESSAGE_ERROR, _("Could not create the Name Guru.")); g_free (state); return; } } /** * dialog_define_names: * @wbcg: * * Create and show the define names dialog. **/ void dialog_paste_names (WBCGtk *wbcg) { NameGuruState *state; g_return_if_fail (wbcg != NULL); /* Only one guru per workbook. */ if (wbc_gtk_get_guru (wbcg)) return; /* Only pop up one copy per workbook */ if (gnumeric_dialog_raise_if_exists (wbcg, PASTE_NAMES_KEY)) return; state = g_new0 (NameGuruState, 1); if (name_guru_init (state, wbcg, TRUE)) { go_gtk_notice_dialog (wbcg_toplevel (wbcg), GTK_MESSAGE_ERROR, _("Could not create the Name Guru.")); g_free (state); return; } }