?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
GUI: Fix context menu for toolbars.
[gnumeric.git] / src / wbc-gtk.c
blobc983e2ff978c98fc59286bc9b5ac2529f75183ee
1 /* vim: set sw=8: -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
2
3 /*
4 * wbc-gtk.c: A gtk based WorkbookControl
5 *
6 * Copyright (C) 2000-2007 Jody Goldberg (jody@gnome.org)
7 * Copyright (C) 2006-2012 Morten Welinder (terra@gnome.org)
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License as
11 * published by the Free Software Foundation; either version 2 of the
12 * License, or (at your option) version 3.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
22 * USA
23 */
24 #include <gnumeric-config.h>
25 #include "gnumeric.h"
26 #include "wbc-gtk-impl.h"
27 #include "workbook-view.h"
28 #include "workbook-priv.h"
29 #include "gui-util.h"
30 #include "gutils.h"
31 #include "gui-file.h"
32 #include "sheet-control-gui-priv.h"
33 #include "sheet.h"
34 #include "sheet-private.h"
35 #include "sheet-view.h"
36 #include "sheet-style.h"
37 #include "sheet-filter.h"
38 #include "commands.h"
39 #include "dependent.h"
40 #include "application.h"
41 #include "history.h"
42 #include "func.h"
43 #include "value.h"
44 #include "style-font.h"
45 #include "gnm-format.h"
46 #include "expr.h"
47 #include "style-color.h"
48 #include "style-border.h"
49 #include "gnumeric-conf.h"
50 #include "dialogs/dialogs.h"
51 #include "gui-clipboard.h"
52 #include "libgnumeric.h"
53 #include "gnm-pane-impl.h"
54 #include "graph.h"
55 #include "selection.h"
56 #include "file-autoft.h"
57 #include "ranges.h"
58 #include "tools/analysis-auto-expression.h"
59 #include "sheet-object-cell-comment.h"
60 #include "print-info.h"
61 #include "expr-name.h"
62
63 #include <goffice/goffice.h>
64 #include <gsf/gsf-impl-utils.h>
65 #include <gsf/gsf-doc-meta-data.h>
66 #include <gtk/gtk.h>
67 #include "gdk/gdkkeysyms-compat.h"
68 #include "gnm-i18n.h"
69 #include <string.h>
70
71 #define GET_GUI_ITEM(i_) (gpointer)(gtk_builder_get_object(wbcg->gui, (i_)))
72
73 #define SHEET_CONTROL_KEY "SheetControl"
74
75 #define AUTO_EXPR_SAMPLE "Sumerage = -012345678901234"
76
77
78 enum {
79 WBG_GTK_PROP_0,
80 WBG_GTK_PROP_AUTOSAVE_PROMPT,
81 WBG_GTK_PROP_AUTOSAVE_TIME
82 };
83
84 enum {
85 WBC_GTK_MARKUP_CHANGED,
86 WBC_GTK_LAST_SIGNAL
87 };
88
89 enum {
90 TARGET_URI_LIST,
91 TARGET_SHEET
92 };
93
94
95 static gboolean debug_tab_order;
96 static char const *uifilename = NULL;
97 static GtkActionEntry const *extra_actions = NULL;
98 static int extra_actions_nb;
99 static guint wbc_gtk_signals[WBC_GTK_LAST_SIGNAL];
100 static GObjectClass *parent_class = NULL;
101
102 static gboolean
103 wbcg_ui_update_begin (WBCGtk *wbcg)
104 {
105 g_return_val_if_fail (GNM_IS_WBC_GTK (wbcg), FALSE);
106 g_return_val_if_fail (!wbcg->updating_ui, FALSE);
107
108 return (wbcg->updating_ui = TRUE);
109 }
110
111 static void
112 wbcg_ui_update_end (WBCGtk *wbcg)
113 {
114 g_return_if_fail (GNM_IS_WBC_GTK (wbcg));
115 g_return_if_fail (wbcg->updating_ui);
116
117 wbcg->updating_ui = FALSE;
118 }
119
120 /****************************************************************************/
121
122 G_MODULE_EXPORT void
123 set_uifilename (char const *name, GtkActionEntry const *actions, int nb)
124 {
125 uifilename = name;
126 extra_actions = actions;
127 extra_actions_nb = nb;
128 }
129
130 /**
131 * wbcg_find_action:
132 * @wbcg: the workbook control gui
133 * @name: name of action
134 *
135 * Returns: (transfer none): The action with the given name
136 **/
137 GtkAction *
138 wbcg_find_action (WBCGtk *wbcg, const char *name)
139 {
140 GtkAction *a;
141
142 a = gtk_action_group_get_action (wbcg->actions, name);
143 if (a == NULL)
144 a = gtk_action_group_get_action (wbcg->permanent_actions, name);
145 if (a == NULL)
146 a = gtk_action_group_get_action (wbcg->semi_permanent_actions, name);
147 if (a == NULL)
148 a = gtk_action_group_get_action (wbcg->data_only_actions, name);
149 if (a == NULL)
150 a = gtk_action_group_get_action (wbcg->font_actions, name);
151 if (a == NULL)
152 a = gtk_action_group_get_action (wbcg->toolbar.actions, name);
153
154 return a;
155 }
156
157 static void
158 wbc_gtk_set_action_sensitivity (WBCGtk *wbcg,
159 char const *action, gboolean sensitive)
160 {
161 GtkAction *a = wbcg_find_action (wbcg, action);
162 g_object_set (G_OBJECT (a), "sensitive", sensitive, NULL);
163 }
164
165 /* NOTE : The semantics of prefix and suffix seem contrived. Why are we
166 * handling it at this end ? That stuff should be done in the undo/redo code
167 **/
168 static void
169 wbc_gtk_set_action_label (WBCGtk *wbcg,
170 char const *action,
171 char const *prefix,
172 char const *suffix,
173 char const *new_tip)
174 {
175 GtkAction *a = wbcg_find_action (wbcg, action);
176
177 if (prefix != NULL) {
178 char *text;
179 gboolean is_suffix = (suffix != NULL);
180
181 text = is_suffix ? g_strdup_printf ("%s: %s", prefix, suffix) : (char *) prefix;
182 g_object_set (G_OBJECT (a),
183 "label", text,
184 "sensitive", is_suffix,
185 NULL);
186 if (is_suffix)
187 g_free (text);
188 } else
189 g_object_set (G_OBJECT (a), "label", suffix, NULL);
190
191 if (new_tip != NULL)
192 g_object_set (G_OBJECT (a), "tooltip", new_tip, NULL);
193 }
194
195 static void
196 wbc_gtk_set_toggle_action_state (WBCGtk *wbcg,
197 char const *action, gboolean state)
198 {
199 GtkAction *a = wbcg_find_action (wbcg, action);
200 gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (a), state);
201 }
202
203 /****************************************************************************/
204
205 static SheetControlGUI *
206 wbcg_get_scg (WBCGtk *wbcg, Sheet *sheet)
207 {
208 SheetControlGUI *scg;
209 int i, npages;
210
211 if (sheet == NULL || wbcg->snotebook == NULL)
212 return NULL;
213
214 npages = wbcg_get_n_scg (wbcg);
215 if (npages == 0) {
216 /*
217 * This can happen during construction when the clipboard is
218 * being cleared. Ctrl-C Ctrl-Q.
219 */
220 return NULL;
221 }
222
223 g_return_val_if_fail (IS_SHEET (sheet), NULL);
224 g_return_val_if_fail (sheet->index_in_wb >= 0, NULL);
225
226 scg = wbcg_get_nth_scg (wbcg, sheet->index_in_wb);
227 if (NULL != scg && scg_sheet (scg) == sheet)
228 return scg;
229
230 /*
231 * index_in_wb is probably not accurate because we are in the
232 * middle of removing or adding a sheet.
233 */
234 for (i = 0; i < npages; i++) {
235 scg = wbcg_get_nth_scg (wbcg, i);
236 if (NULL != scg && scg_sheet (scg) == sheet)
237 return scg;
238 }
239
240 g_warning ("Failed to find scg for sheet %s", sheet->name_quoted);
241 return NULL;
242 }
243
244 static SheetControlGUI *
245 get_scg (const GtkWidget *w)
246 {
247 return g_object_get_data (G_OBJECT (w), SHEET_CONTROL_KEY);
248 }
249
250 static GSList *
251 get_all_scgs (WBCGtk *wbcg)
252 {
253 int i, n = gtk_notebook_get_n_pages (wbcg->snotebook);
254 GSList *l = NULL;
255
256 for (i = 0; i < n; i++) {
257 GtkWidget *w = gtk_notebook_get_nth_page (wbcg->snotebook, i);
258 SheetControlGUI *scg = get_scg (w);
259 l = g_slist_prepend (l, scg);
260 }
261
262 return g_slist_reverse (l);
263 }
264
265 /* Autosave */
266
267 static gboolean
268 cb_autosave (WBCGtk *wbcg)
269 {
270 WorkbookView *wb_view;
271
272 g_return_val_if_fail (GNM_IS_WBC_GTK (wbcg), FALSE);
273
274 wb_view = wb_control_view (GNM_WBC (wbcg));
275
276 if (wb_view == NULL)
277 return FALSE;
278
279 if (wbcg->autosave_time > 0 &&
280 go_doc_is_dirty (wb_view_get_doc (wb_view))) {
281 if (wbcg->autosave_prompt && !dialog_autosave_prompt (wbcg))
282 return TRUE;
283 gui_file_save (wbcg, wb_view);
284 }
285 return TRUE;
286 }
287
288 /**
289 * wbcg_rangesel_possible:
290 * @wbcg: the workbook control gui
291 *
292 * Returns true if the cursor keys should be used to select
293 * a cell range (if the cursor is in a spot in the expression
294 * where it makes sense to have a cell reference), false if not.
295 **/
296 gboolean
297 wbcg_rangesel_possible (WBCGtk const *wbcg)
298 {
299 g_return_val_if_fail (GNM_IS_WBC_GTK (wbcg), FALSE);
300
301 /* Already range selecting */
302 if (wbcg->rangesel != NULL)
303 return TRUE;
304
305 /* Rangesel requires that we be editing somthing */
306 if (!wbcg_is_editing (wbcg) && !wbcg_entry_has_logical (wbcg))
307 return FALSE;
308
309 return gnm_expr_entry_can_rangesel (wbcg_get_entry_logical (wbcg));
310 }
311
312 gboolean
313 wbcg_is_editing (WBCGtk const *wbcg)
314 {
315 g_return_val_if_fail (GNM_IS_WBC_GTK (wbcg), FALSE);
316 return wbcg->editing;
317 }
318
319 static void
320 wbcg_autosave_cancel (WBCGtk *wbcg)
321 {
322 if (wbcg->autosave_timer != 0) {
323 g_source_remove (wbcg->autosave_timer);
324 wbcg->autosave_timer = 0;
325 }
326 }
327
328 static void
329 wbcg_autosave_activate (WBCGtk *wbcg)
330 {
331 wbcg_autosave_cancel (wbcg);
332
333 if (wbcg->autosave_time > 0) {
334 int secs = MIN (wbcg->autosave_time, G_MAXINT / 1000);
335 wbcg->autosave_timer =
336 g_timeout_add (secs * 1000,
337 (GSourceFunc) cb_autosave,
338 wbcg);
339 }
340 }
341
342 static void
343 wbcg_set_autosave_time (WBCGtk *wbcg, int secs)
344 {
345 if (secs == wbcg->autosave_time)
346 return;
347
348 wbcg->autosave_time = secs;
349 wbcg_autosave_activate (wbcg);
350 }
351
352 /****************************************************************************/
353
354 static void
355 wbcg_edit_line_set (WorkbookControl *wbc, char const *text)
356 {
357 GtkEntry *entry = wbcg_get_entry ((WBCGtk*)wbc);
358 gtk_entry_set_text (entry, text);
359 }
360
361 static void
362 wbcg_edit_selection_descr_set (WorkbookControl *wbc, char const *text)
363 {
364 WBCGtk *wbcg = (WBCGtk *)wbc;
365 gtk_entry_set_text (GTK_ENTRY (wbcg->selection_descriptor), text);
366 }
367
368 static void
369 wbcg_update_action_sensitivity (WorkbookControl *wbc)
370 {
371 WBCGtk *wbcg = WBC_GTK (wbc);
372 SheetControlGUI *scg = wbcg_cur_scg (wbcg);
373 gboolean edit_object = scg != NULL &&
374 (scg->selected_objects != NULL || wbcg->new_object != NULL ||
375 scg_sheet (scg)->sheet_type == GNM_SHEET_OBJECT);
376 gboolean enable_actions = TRUE;
377 gboolean enable_edit_ok_cancel = FALSE;
378
379 if (edit_object || wbcg->edit_line.guru != NULL)
380 enable_actions = FALSE;
381 else if (wbcg_is_editing (wbcg)) {
382 enable_actions = FALSE;
383 enable_edit_ok_cancel = TRUE;
384 }
385
386 /* These are only sensitive while editing */
387 gtk_widget_set_sensitive (wbcg->ok_button, enable_edit_ok_cancel);
388 gtk_widget_set_sensitive (wbcg->cancel_button, enable_edit_ok_cancel);
389 gtk_widget_set_sensitive (wbcg->func_button, enable_actions);
390
391 if (wbcg->snotebook) {
392 gboolean tab_context_menu =
393 enable_actions ||
394 scg_sheet (scg)->sheet_type == GNM_SHEET_OBJECT;
395 int i, N = wbcg_get_n_scg (wbcg);
396 for (i = 0; i < N; i++) {
397 GtkWidget *label =
398 gnm_notebook_get_nth_label (wbcg->bnotebook, i);
399 g_object_set_data (G_OBJECT (label), "editable",
400 GINT_TO_POINTER (tab_context_menu));
401 }
402 }
403
404 g_object_set (G_OBJECT (wbcg->actions),
405 "sensitive", enable_actions,
406 NULL);
407 g_object_set (G_OBJECT (wbcg->font_actions),
408 "sensitive", enable_actions || enable_edit_ok_cancel,
409 NULL);
410
411 if (scg && scg_sheet (scg)->sheet_type == GNM_SHEET_OBJECT) {
412 g_object_set (G_OBJECT (wbcg->data_only_actions),
413 "sensitive", FALSE,
414 NULL);
415 g_object_set (G_OBJECT (wbcg->semi_permanent_actions),
416 "sensitive",TRUE,
417 NULL);
418 gtk_widget_set_sensitive (GTK_WIDGET (wbcg->edit_line.entry), FALSE);
419 gtk_widget_set_sensitive (GTK_WIDGET (wbcg->selection_descriptor), FALSE);
420 } else {
421 g_object_set (G_OBJECT (wbcg->data_only_actions),
422 "sensitive", TRUE,
423 NULL);
424 g_object_set (G_OBJECT (wbcg->semi_permanent_actions),
425 "sensitive", enable_actions,
426 NULL);
427 gtk_widget_set_sensitive (GTK_WIDGET (wbcg->edit_line.entry), TRUE);
428 gtk_widget_set_sensitive (GTK_WIDGET (wbcg->selection_descriptor), TRUE);
429 }
430 }
431
432 void
433 wbcg_insert_sheet (GtkWidget *unused, WBCGtk *wbcg)
434 {
435 WorkbookControl *wbc = GNM_WBC (wbcg);
436 Sheet *sheet = wb_control_cur_sheet (wbc);
437 Workbook *wb = sheet->workbook;
438 WorkbookSheetState *old_state = workbook_sheet_state_new (wb);
439 /* Use same size as current sheet. */
440 workbook_sheet_add (wb, sheet->index_in_wb,
441 gnm_sheet_get_max_cols (sheet),
442 gnm_sheet_get_max_rows (sheet));
443 cmd_reorganize_sheets (wbc, old_state, sheet);
444 }
445
446 void
447 wbcg_append_sheet (GtkWidget *unused, WBCGtk *wbcg)
448 {
449 WorkbookControl *wbc = GNM_WBC (wbcg);
450 Sheet *sheet = wb_control_cur_sheet (wbc);
451 Workbook *wb = sheet->workbook;
452 WorkbookSheetState *old_state = workbook_sheet_state_new (wb);
453 /* Use same size as current sheet. */
454 workbook_sheet_add (wb, -1,
455 gnm_sheet_get_max_cols (sheet),
456 gnm_sheet_get_max_rows (sheet));
457 cmd_reorganize_sheets (wbc, old_state, sheet);
458 }
459
460 void
461 wbcg_clone_sheet (GtkWidget *unused, WBCGtk *wbcg)
462 {
463 WorkbookControl *wbc = GNM_WBC (wbcg);
464 Sheet *sheet = wb_control_cur_sheet (wbc);
465 Workbook *wb = sheet->workbook;
466 WorkbookSheetState *old_state = workbook_sheet_state_new (wb);
467 Sheet *new_sheet = sheet_dup (sheet);
468 workbook_sheet_attach_at_pos (wb, new_sheet, sheet->index_in_wb + 1);
469 /* See workbook_sheet_add: */
470 g_signal_emit_by_name (G_OBJECT (wb), "sheet_added", 0);
471 cmd_reorganize_sheets (wbc, old_state, sheet);
472 g_object_unref (new_sheet);
473 }
474
475 static void
476 cb_show_sheet (SheetControlGUI *scg)
477 {
478 WBCGtk *wbcg = scg->wbcg;
479 int page_number = gtk_notebook_page_num (wbcg->snotebook,
480 GTK_WIDGET (scg->grid));
481 gnm_notebook_set_current_page (wbcg->bnotebook, page_number);
482 }
483
484
485
486 static void cb_sheets_manage (SheetControlGUI *scg) { dialog_sheet_order (scg->wbcg); }
487 static void cb_sheets_insert (SheetControlGUI *scg) { wbcg_insert_sheet (NULL, scg->wbcg); }
488 static void cb_sheets_add (SheetControlGUI *scg) { wbcg_append_sheet (NULL, scg->wbcg); }
489 static void cb_sheets_clone (SheetControlGUI *scg) { wbcg_clone_sheet (NULL, scg->wbcg); }
490 static void cb_sheets_rename (SheetControlGUI *scg) { dialog_sheet_rename (scg->wbcg, scg_sheet (scg)); }
491 static void cb_sheets_resize (SheetControlGUI *scg) { dialog_sheet_resize (scg->wbcg); }
492
493
494 static gint
495 cb_by_scg_sheet_name (gconstpointer a_, gconstpointer b_)
496 {
497 const SheetControlGUI *a = a_;
498 const SheetControlGUI *b = b_;
499 Sheet *sa = scg_sheet (a);
500 Sheet *sb = scg_sheet (b);
501
502 return g_utf8_collate (sa->name_unquoted, sb->name_unquoted);
503 }
504
505
506 static void
507 sheet_menu_label_run (SheetControlGUI *scg, GdkEvent *event)
508 {
509 enum { CM_MULTIPLE = 1, CM_DATA_SHEET = 2 };
510 struct SheetTabMenu {
511 char const *text;
512 void (*function) (SheetControlGUI *scg);
513 int flags;
514 int submenu;
515 } const sheet_label_context_actions [] = {
516 { N_("Manage Sheets..."), &cb_sheets_manage, 0, 0},
517 { NULL, NULL, 0, 0 },
518 { N_("Insert"), &cb_sheets_insert, 0, 0 },
519 { N_("Append"), &cb_sheets_add, 0, 0 },
520 { N_("Duplicate"), &cb_sheets_clone, 0, 0 },
521 { N_("Remove"), &scg_delete_sheet_if_possible, CM_MULTIPLE, 0 },
522 { N_("Rename"), &cb_sheets_rename, 0, 0 },
523 { N_("Resize..."), &cb_sheets_resize, CM_DATA_SHEET, 0 },
524 { N_("Select"), NULL, 0, 1 },
525 { N_("Select (sorted)"), NULL, 0, 2 }
526 };
527
528 unsigned int ui;
529 GtkWidget *item, *menu = gtk_menu_new ();
530 GtkWidget *guru = wbc_gtk_get_guru (scg_wbcg (scg));
531 unsigned int N_visible, pass;
532 GtkWidget *submenus[2 + 1];
533 GSList *scgs = get_all_scgs (scg->wbcg);
534
535 for (pass = 1; pass <= 2; pass++) {
536 GSList *l;
537
538 submenus[pass] = gtk_menu_new ();
539 N_visible = 0;
540 for (l = scgs; l; l = l->next) {
541 SheetControlGUI *scg1 = l->data;
542 Sheet *sheet = scg_sheet (scg1);
543 if (!sheet_is_visible (sheet))
544 continue;
545
546 N_visible++;
547
548 item = gtk_menu_item_new_with_label (sheet->name_unquoted);
549 g_signal_connect_swapped (G_OBJECT (item), "activate",
550 G_CALLBACK (cb_show_sheet), scg1);
551 gtk_menu_shell_append (GTK_MENU_SHELL (submenus[pass]), item);
552 gtk_widget_show (item);
553 }
554
555 scgs = g_slist_sort (scgs, cb_by_scg_sheet_name);
556 }
557 g_slist_free (scgs);
558
559 for (ui = 0; ui < G_N_ELEMENTS (sheet_label_context_actions); ui++) {
560 const struct SheetTabMenu *it =
561 sheet_label_context_actions + ui;
562 gboolean inactive =
563 ((it->flags & CM_MULTIPLE) && N_visible <= 1) ||
564 ((it->flags & CM_DATA_SHEET) && scg_sheet (scg)->sheet_type != GNM_SHEET_DATA) ||
565 (!it->submenu && guru != NULL);
566
567 item = it->text
568 ? gtk_menu_item_new_with_label (_(it->text))
569 : gtk_separator_menu_item_new ();
570 if (it->function)
571 g_signal_connect_swapped (G_OBJECT (item), "activate",
572 G_CALLBACK (it->function), scg);
573 if (it->submenu)
574 gtk_menu_item_set_submenu (GTK_MENU_ITEM (item),
575 submenus[it->submenu]);
576
577 gtk_widget_set_sensitive (item, !inactive);
578 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
579 gtk_widget_show (item);
580 }
581
582 gnumeric_popup_menu (GTK_MENU (menu), event);
583 }
584
585 /**
586 * cb_sheet_label_button_press:
587 *
588 * Invoked when the user has clicked on the sheet name widget.
589 * This takes care of switching to the notebook that contains the label
590 */
591 static gboolean
592 cb_sheet_label_button_press (GtkWidget *widget, GdkEvent *event,
593 SheetControlGUI *scg)
594 {
595 WBCGtk *wbcg = scg->wbcg;
596 gint page_number;
597
598 if (event->type != GDK_BUTTON_PRESS)
599 return FALSE;
600
601 page_number = gtk_notebook_page_num (wbcg->snotebook,
602 GTK_WIDGET (scg->grid));
603 gnm_notebook_set_current_page (wbcg->bnotebook, page_number);
604
605 if (event->button.button == 1 || NULL != wbcg->rangesel)
606 return FALSE;
607
608 if (event->button.button == 3) {
609 if ((scg_wbcg (scg))->edit_line.guru == NULL)
610 scg_object_unselect (scg, NULL);
611 if (g_object_get_data (G_OBJECT (widget), "editable")) {
612 sheet_menu_label_run (scg, event);
613 scg_take_focus (scg);
614 return TRUE;
615 }
616 }
617
618 return FALSE;
619 }
620
621 static void
622 cb_sheet_label_drag_data_get (GtkWidget *widget, GdkDragContext *context,
623 GtkSelectionData *selection_data,
624 guint info, guint time)
625 {
626 SheetControlGUI *scg = get_scg (widget);
627 g_return_if_fail (GNM_IS_SCG (scg));
628
629 scg_drag_data_get (scg, selection_data);
630 }
631
632 static void
633 cb_sheet_label_drag_data_received (GtkWidget *widget, GdkDragContext *context,
634 gint x, gint y, GtkSelectionData *data, guint info, guint time,
635 WBCGtk *wbcg)
636 {
637 GtkWidget *w_source;
638 SheetControlGUI *scg_src, *scg_dst;
639 Sheet *s_src, *s_dst;
640
641 g_return_if_fail (GNM_IS_WBC_GTK (wbcg));
642 g_return_if_fail (GTK_IS_WIDGET (widget));
643
644 w_source = gtk_drag_get_source_widget (context);
645 if (!w_source) {
646 g_warning ("Not yet implemented!"); /* Different process */
647 return;
648 }
649
650 scg_src = get_scg (w_source);
651 g_return_if_fail (scg_src != NULL);
652 s_src = scg_sheet (scg_src);
653
654 scg_dst = get_scg (widget);
655 g_return_if_fail (scg_dst != NULL);
656 s_dst = scg_sheet (scg_dst);
657
658 if (s_src == s_dst) {
659 /* Nothing */
660 } else if (s_src->workbook == s_dst->workbook) {
661 /* Move within workbook */
662 Workbook *wb = s_src->workbook;
663 int p_src = s_src->index_in_wb;
664 int p_dst = s_dst->index_in_wb;
665 WorkbookSheetState *old_state = workbook_sheet_state_new (wb);
666 workbook_sheet_move (s_src, p_dst - p_src);
667 cmd_reorganize_sheets (GNM_WBC (wbcg),
668 old_state,
669 s_src);
670 } else {
671 g_return_if_fail (GNM_IS_SCG (gtk_selection_data_get_data (data)));
672
673 /* Different workbook, same process */
674 g_warning ("Not yet implemented!");
675 }
676 }
677
678 /*
679 * Not currently reachable, I believe. We use the notebook's dragging.
680 */
681 static void
682 cb_sheet_label_drag_begin (GtkWidget *widget, GdkDragContext *context,
683 WBCGtk *wbcg)
684 {
685 GtkWidget *arrow, *image;
686
687 g_return_if_fail (GNM_IS_WBC_GTK (wbcg));
688
689 /* Create the arrow. */
690 arrow = gtk_window_new (GTK_WINDOW_POPUP);
691 gtk_window_set_screen (GTK_WINDOW (arrow),
692 gtk_widget_get_screen (widget));
693 gtk_widget_realize (arrow);
694 image = gtk_image_new_from_resource ("/org/gnumeric/gnumeric/images/sheet_move_marker.png");
695 gtk_widget_show (image);
696 gtk_container_add (GTK_CONTAINER (arrow), image);
697 g_object_ref_sink (arrow);
698 g_object_set_data (G_OBJECT (widget), "arrow", arrow);
699 }
700
701 static void
702 cb_sheet_label_drag_end (GtkWidget *widget, GdkDragContext *context,
703 WBCGtk *wbcg)
704 {
705 GtkWidget *arrow;
706
707 g_return_if_fail (GNM_IS_WBC (wbcg));
708
709 /* Destroy the arrow. */
710 arrow = g_object_get_data (G_OBJECT (widget), "arrow");
711 gtk_widget_destroy (arrow);
712 g_object_unref (arrow);
713 g_object_set_data (G_OBJECT (widget), "arrow", NULL);
714 }
715
716 static void
717 cb_sheet_label_drag_leave (GtkWidget *widget, GdkDragContext *context,
718 guint time, WBCGtk *wbcg)
719 {
720 GtkWidget *w_source, *arrow;
721
722 /* Hide the arrow. */
723 w_source = gtk_drag_get_source_widget (context);
724 if (w_source) {
725 arrow = g_object_get_data (G_OBJECT (w_source), "arrow");
726 gtk_widget_hide (arrow);
727 }
728 }
729
730 static gboolean
731 cb_sheet_label_drag_motion (GtkWidget *widget, GdkDragContext *context,
732 gint x, gint y, guint time, WBCGtk *wbcg)
733 {
734 SheetControlGUI *scg_src, *scg_dst;
735 GtkWidget *w_source, *arrow, *window;
736 gint root_x, root_y, pos_x, pos_y;
737 GtkAllocation wa, wsa;
738
739 g_return_val_if_fail (GNM_IS_WBC_GTK (wbcg), FALSE);
740 g_return_val_if_fail (GNM_IS_WBC_GTK (wbcg), FALSE);
741
742 /* Make sure we are really hovering over another label. */
743 w_source = gtk_drag_get_source_widget (context);
744 if (!w_source)
745 return FALSE;
746
747 arrow = g_object_get_data (G_OBJECT (w_source), "arrow");
748
749 scg_src = get_scg (w_source);
750 scg_dst = get_scg (widget);
751
752 if (scg_src == scg_dst) {
753 gtk_widget_hide (arrow);
754 return (FALSE);
755 }
756
757 /* Move the arrow to the correct position and show it. */
758 window = gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW);
759 gtk_window_get_position (GTK_WINDOW (window), &root_x, &root_y);
760 gtk_widget_get_allocation (widget ,&wa);
761 pos_x = root_x + wa.x;
762 pos_y = root_y + wa.y;
763 gtk_widget_get_allocation (w_source ,&wsa);
764 if (wsa.x < wa.x)
765 pos_x += wa.width;
766 gtk_window_move (GTK_WINDOW (arrow), pos_x, pos_y);
767 gtk_widget_show (arrow);
768
769 return (TRUE);
770 }
771
772 static void
773 set_dir (GtkWidget *w, GtkTextDirection *dir)
774 {
775 gtk_widget_set_direction (w, *dir);
776 if (GTK_IS_CONTAINER (w))
777 gtk_container_foreach (GTK_CONTAINER (w),
778 (GtkCallback)&set_dir,
779 dir);
780 }
781
782 static void
783 wbcg_set_direction (SheetControlGUI const *scg)
784 {
785 GtkWidget *w = (GtkWidget *)scg->wbcg->snotebook;
786 gboolean text_is_rtl = scg_sheet (scg)->text_is_rtl;
787 GtkTextDirection dir = text_is_rtl
788 ? GTK_TEXT_DIR_RTL
789 : GTK_TEXT_DIR_LTR;
790
791 if (dir != gtk_widget_get_direction (w))
792 set_dir (w, &dir);
793 if (scg->hs)
794 g_object_set (scg->hs, "inverted", text_is_rtl, NULL);
795 }
796
797 static void
798 cb_direction_change (G_GNUC_UNUSED Sheet *null_sheet,
799 G_GNUC_UNUSED GParamSpec *null_pspec,
800 SheetControlGUI const *scg)
801 {
802 if (scg && scg == wbcg_cur_scg (scg->wbcg))
803 wbcg_set_direction (scg);
804 }
805
806 static void
807 wbcg_update_menu_feedback (WBCGtk *wbcg, Sheet const *sheet)
808 {
809 g_return_if_fail (IS_SHEET (sheet));
810
811 if (!wbcg_ui_update_begin (wbcg))
812 return;
813
814 wbc_gtk_set_toggle_action_state (wbcg,
815 "SheetDisplayFormulas", sheet->display_formulas);
816 wbc_gtk_set_toggle_action_state (wbcg,
817 "SheetHideZeros", sheet->hide_zero);
818 wbc_gtk_set_toggle_action_state (wbcg,
819 "SheetHideGridlines", sheet->hide_grid);
820 wbc_gtk_set_toggle_action_state (wbcg,
821 "SheetHideColHeader", sheet->hide_col_header);
822 wbc_gtk_set_toggle_action_state (wbcg,
823 "SheetHideRowHeader", sheet->hide_row_header);
824 wbc_gtk_set_toggle_action_state (wbcg,
825 "SheetDisplayOutlines", sheet->display_outlines);
826 wbc_gtk_set_toggle_action_state (wbcg,
827 "SheetOutlineBelow", sheet->outline_symbols_below);
828 wbc_gtk_set_toggle_action_state (wbcg,
829 "SheetOutlineRight", sheet->outline_symbols_right);
830 wbc_gtk_set_toggle_action_state (wbcg,
831 "SheetUseR1C1", sheet->convs->r1c1_addresses);
832 wbcg_ui_update_end (wbcg);
833 }
834
835 static void
836 cb_zoom_change (Sheet *sheet,
837 G_GNUC_UNUSED GParamSpec *null_pspec,
838 WBCGtk *wbcg)
839 {
840 if (wbcg_ui_update_begin (wbcg)) {
841 int pct = sheet->last_zoom_factor_used * 100 + .5;
842 char *label = g_strdup_printf ("%d%%", pct);
843 go_action_combo_text_set_entry (wbcg->zoom_haction, label,
844 GO_ACTION_COMBO_SEARCH_CURRENT);
845 g_free (label);
846 wbcg_ui_update_end (wbcg);
847 }
848 }
849
850 static void
851 cb_notebook_switch_page (G_GNUC_UNUSED GtkNotebook *notebook_,
852 G_GNUC_UNUSED GtkWidget *page_,
853 guint page_num, WBCGtk *wbcg)
854 {
855 Sheet *sheet;
856 SheetControlGUI *new_scg;
857
858 g_return_if_fail (GNM_IS_WBC_GTK (wbcg));
859
860 /* Ignore events during destruction */
861 if (wbcg->snotebook == NULL)
862 return;
863
864 if (debug_tab_order)
865 g_printerr ("Notebook page switch\n");
866
867 /* While initializing adding the sheets will trigger page changes, but
868 * we do not actually want to change the focus sheet for the view
869 */
870 if (wbcg->updating_ui)
871 return;
872
873 /* If we are not at a subexpression boundary then finish editing */
874 if (NULL != wbcg->rangesel)
875 scg_rangesel_stop (wbcg->rangesel, TRUE);
876
877 /*
878 * Make snotebook follow bnotebook. This should be the only place
879 * that changes pages for snotebook.
880 */
881 gtk_notebook_set_current_page (wbcg->snotebook, page_num);
882
883 new_scg = wbcg_get_nth_scg (wbcg, page_num);
884 wbcg_set_direction (new_scg);
885
886 if (wbcg_is_editing (wbcg) && wbcg_rangesel_possible (wbcg)) {
887 /*
888 * When we are editing, sheet changes are not done fully.
889 * We revert to the original sheet later.
890 *
891 * On the other hand, when we are selecting a range for a
892 * dialog, we do change sheet fully.
893 */
894 scg_take_focus (new_scg);
895 return;
896 }
897
898 gnm_expr_entry_set_scg (wbcg->edit_line.entry, new_scg);
899
900 /*
901 * Make absolutely sure the expression doesn't get 'lost',
902 * if it's invalid then prompt the user and don't switch
903 * the notebook page.
904 */
905 if (wbcg_is_editing (wbcg)) {
906 guint prev = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (wbcg->snotebook),
907 "previous_page"));
908
909 if (prev == page_num)
910 return;
911
912 if (!wbcg_edit_finish (wbcg, WBC_EDIT_ACCEPT, NULL))
913 gnm_notebook_set_current_page (wbcg->bnotebook,
914 prev);
915 else
916 /* Looks silly, but is really neccesarry */
917 gnm_notebook_set_current_page (wbcg->bnotebook,
918 page_num);
919
920 return;
921 }
922
923 g_object_set_data (G_OBJECT (wbcg->snotebook), "previous_page",
924 GINT_TO_POINTER (gtk_notebook_get_current_page (wbcg->snotebook)));
925
926 /* if we are not selecting a range for an expression update */
927 sheet = wbcg_focus_cur_scg (wbcg);
928 if (sheet != wbcg_cur_sheet (wbcg)) {
929 wbcg_update_menu_feedback (wbcg, sheet);
930 sheet_flag_status_update_range (sheet, NULL);
931 sheet_update (sheet);
932 wb_view_sheet_focus (wb_control_view (GNM_WBC (wbcg)), sheet);
933 cb_zoom_change (sheet, NULL, wbcg);
934 }
935 }
936
937 static gboolean
938 cb_bnotebook_button_press (GtkWidget *widget, GdkEventButton *event)
939 {
940 if (event->type == GDK_2BUTTON_PRESS && event->button == 1) {
941 /*
942 * Eat the click so cb_paned_button_press doesn't see it.
943 * see bug #607794.
944 */
945 return TRUE;
946 }
947
948 return FALSE;
949 }
950
951 static void
952 cb_bnotebook_page_reordered (GtkNotebook *notebook, GtkWidget *child,
953 int page_num, WBCGtk *wbcg)
954 {
955 GtkNotebook *snotebook = GTK_NOTEBOOK (wbcg->snotebook);
956 int old = gtk_notebook_get_current_page (snotebook);
957
958 if (wbcg->updating_ui)
959 return;
960
961 if (debug_tab_order)
962 g_printerr ("Reordered %d -> %d\n", old, page_num);
963
964 if (old != page_num) {
965 WorkbookControl * wbc = GNM_WBC (wbcg);
966 Workbook *wb = wb_control_get_workbook (wbc);
967 Sheet *sheet = workbook_sheet_by_index (wb, old);
968 WorkbookSheetState * old_state = workbook_sheet_state_new(wb);
969 workbook_sheet_move (sheet, page_num - old);
970 cmd_reorganize_sheets (wbc, old_state, sheet);
971 }
972 }
973
974
975 static void
976 wbc_gtk_create_notebook_area (WBCGtk *wbcg)
977 {
978 GtkWidget *placeholder;
979
980 wbcg->bnotebook = g_object_new (GNM_NOTEBOOK_TYPE,
981 "can-focus", FALSE,
982 NULL);
983 g_object_ref (wbcg->bnotebook);
984
985 g_signal_connect_after (G_OBJECT (wbcg->bnotebook),
986 "switch_page",
987 G_CALLBACK (cb_notebook_switch_page), wbcg);
988 g_signal_connect (G_OBJECT (wbcg->bnotebook),
989 "button-press-event",
990 G_CALLBACK (cb_bnotebook_button_press),
991 NULL);
992 g_signal_connect (G_OBJECT (wbcg->bnotebook),
993 "page-reordered",
994 G_CALLBACK (cb_bnotebook_page_reordered),
995 wbcg);
996 placeholder = gtk_paned_get_child1 (wbcg->tabs_paned);
997 if (placeholder)
998 gtk_widget_destroy (placeholder);
999 gtk_paned_pack1 (wbcg->tabs_paned, GTK_WIDGET (wbcg->bnotebook), FALSE, TRUE);
1000
1001 gtk_widget_show_all (GTK_WIDGET (wbcg->tabs_paned));
1002 }
1003
1004
1005 static void
1006 wbcg_menu_state_sheet_count (WBCGtk *wbcg)
1007 {
1008 int const sheet_count = gnm_notebook_get_n_visible (wbcg->bnotebook);
1009 /* Should we enable commands requiring multiple sheets */
1010 gboolean const multi_sheet = (sheet_count > 1);
1011
1012 wbc_gtk_set_action_sensitivity (wbcg, "SheetRemove", multi_sheet);
1013 }
1014
1015 static void
1016 cb_sheet_direction_change (Sheet *sheet,
1017 G_GNUC_UNUSED GParamSpec *pspec,
1018 GtkAction *a)
1019 {
1020 g_object_set (a,
1021 "icon-name", (sheet->text_is_rtl
1022 ? "format-text-direction-rtl"
1023 : "format-text-direction-ltr"),
1024 NULL);
1025 }
1026
1027 static void
1028 cb_sheet_tab_change (Sheet *sheet,
1029 G_GNUC_UNUSED GParamSpec *pspec,
1030 GtkWidget *widget)
1031 {
1032 GdkRGBA cfore, cback;
1033 SheetControlGUI *scg = get_scg (widget);
1034
1035 g_return_if_fail (GNM_IS_SCG (scg));
1036
1037 /* We're lazy and just set all relevant attributes. */
1038 g_object_set (widget,
1039 "label", sheet->name_unquoted,
1040 "background-color",
1041 (sheet->tab_color
1042 ? go_color_to_gdk_rgba (sheet->tab_color->go_color,
1043 &cback)
1044 : NULL),
1045 "text-color",
1046 (sheet->tab_text_color
1047 ? go_color_to_gdk_rgba (sheet->tab_text_color->go_color,
1048 &cfore)
1049 : NULL),
1050 NULL);
1051 }
1052
1053 static void
1054 cb_toggle_menu_item_changed (Sheet *sheet,
1055 G_GNUC_UNUSED GParamSpec *pspec,
1056 WBCGtk *wbcg)
1057 {
1058 /* We're lazy and just update all. */
1059 wbcg_update_menu_feedback (wbcg, sheet);
1060 }
1061
1062 static void
1063 cb_sheet_visibility_change (Sheet *sheet,
1064 G_GNUC_UNUSED GParamSpec *pspec,
1065 SheetControlGUI *scg)
1066 {
1067 gboolean viz;
1068
1069 g_return_if_fail (GNM_IS_SCG (scg));
1070
1071 viz = sheet_is_visible (sheet);
1072 gtk_widget_set_visible (GTK_WIDGET (scg->grid), viz);
1073 gtk_widget_set_visible (GTK_WIDGET (scg->label), viz);
1074
1075 wbcg_menu_state_sheet_count (scg->wbcg);
1076 }
1077
1078 static void
1079 disconnect_sheet_focus_signals (WBCGtk *wbcg)
1080 {
1081 SheetControlGUI *scg = wbcg->active_scg;
1082 Sheet *sheet;
1083
1084 if (!scg)
1085 return;
1086
1087 sheet = scg_sheet (scg);
1088
1089 #if 0
1090 g_printerr ("Disconnecting focus for %s with scg=%p\n", sheet->name_unquoted, scg);
1091 #endif
1092
1093 g_signal_handlers_disconnect_by_func (sheet, cb_toggle_menu_item_changed, wbcg);
1094 g_signal_handlers_disconnect_by_func (sheet, cb_direction_change, scg);
1095 g_signal_handlers_disconnect_by_func (sheet, cb_zoom_change, wbcg);
1096
1097 wbcg->active_scg = NULL;
1098 }
1099
1100 static void
1101 disconnect_sheet_signals (SheetControlGUI *scg)
1102 {
1103 WBCGtk *wbcg = scg->wbcg;
1104 Sheet *sheet = scg_sheet (scg);
1105
1106 if (scg == wbcg->active_scg)
1107 disconnect_sheet_focus_signals (wbcg);
1108
1109 #if 0
1110 g_printerr ("Disconnecting all for %s with scg=%p\n", sheet->name_unquoted, scg);
1111 #endif
1112
1113 g_signal_handlers_disconnect_by_func (sheet, cb_sheet_direction_change,
1114 wbcg_find_action (wbcg, "SheetDirection"));
1115 g_signal_handlers_disconnect_by_func (sheet, cb_sheet_tab_change, scg->label);
1116 g_signal_handlers_disconnect_by_func (sheet, cb_sheet_visibility_change, scg);
1117 }
1118
1119 static void
1120 wbcg_sheet_add (WorkbookControl *wbc, SheetView *sv)
1121 {
1122 static GtkTargetEntry const drag_types[] = {
1123 { (char *)"GNUMERIC_SHEET", GTK_TARGET_SAME_APP, TARGET_SHEET },
1124 { (char *)"UTF8_STRING", 0, 0 },
1125 { (char *)"image/svg+xml", 0, 0 },
1126 { (char *)"image/x-wmf", 0, 0 },
1127 { (char *)"image/x-emf", 0, 0 },
1128 { (char *)"image/png", 0, 0 },
1129 { (char *)"image/jpeg", 0, 0 },
1130 { (char *)"image/bmp", 0, 0 }
1131 };
1132
1133 WBCGtk *wbcg = (WBCGtk *)wbc;
1134 SheetControlGUI *scg;
1135 Sheet *sheet = sv_sheet (sv);
1136 gboolean visible = sheet_is_visible (sheet);
1137
1138 g_return_if_fail (wbcg != NULL);
1139
1140 scg = sheet_control_gui_new (sv, wbcg);
1141
1142 g_object_set_data (G_OBJECT (scg->grid), SHEET_CONTROL_KEY, scg);
1143
1144 g_object_set_data (G_OBJECT (scg->label), SHEET_CONTROL_KEY, scg);
1145
1146 /* do not preempt the editable label handler */
1147 g_signal_connect_after (G_OBJECT (scg->label),
1148 "button_press_event",
1149 G_CALLBACK (cb_sheet_label_button_press), scg);
1150
1151 /* Drag & Drop */
1152 gtk_drag_source_set (scg->label, GDK_BUTTON1_MASK | GDK_BUTTON3_MASK,
1153 drag_types, G_N_ELEMENTS (drag_types),
1154 GDK_ACTION_MOVE);
1155 gtk_drag_dest_set (scg->label, GTK_DEST_DEFAULT_ALL,
1156 drag_types, G_N_ELEMENTS (drag_types),
1157 GDK_ACTION_MOVE);
1158 g_object_connect (G_OBJECT (scg->label),
1159 "signal::drag_begin", G_CALLBACK (cb_sheet_label_drag_begin), wbcg,
1160 "signal::drag_end", G_CALLBACK (cb_sheet_label_drag_end), wbcg,
1161 "signal::drag_leave", G_CALLBACK (cb_sheet_label_drag_leave), wbcg,
1162 "signal::drag_data_get", G_CALLBACK (cb_sheet_label_drag_data_get), NULL,
1163 "signal::drag_data_received", G_CALLBACK (cb_sheet_label_drag_data_received), wbcg,
1164 "signal::drag_motion", G_CALLBACK (cb_sheet_label_drag_motion), wbcg,
1165 NULL);
1166
1167 gtk_widget_show (scg->label);
1168 gtk_widget_show_all (GTK_WIDGET (scg->grid));
1169 if (!visible) {
1170 gtk_widget_hide (GTK_WIDGET (scg->grid));
1171 gtk_widget_hide (GTK_WIDGET (scg->label));
1172 }
1173 g_object_connect (G_OBJECT (sheet),
1174 "signal::notify::visibility", cb_sheet_visibility_change, scg,
1175 "signal::notify::name", cb_sheet_tab_change, scg->label,
1176 "signal::notify::tab-foreground", cb_sheet_tab_change, scg->label,
1177 "signal::notify::tab-background", cb_sheet_tab_change, scg->label,
1178 "signal::notify::text-is-rtl", cb_sheet_direction_change, wbcg_find_action (wbcg, "SheetDirection"),
1179 NULL);
1180
1181 if (wbcg_ui_update_begin (wbcg)) {
1182 /*
1183 * Just let wbcg_sheet_order_changed deal with where to put
1184 * it.
1185 */
1186 int pos = -1;
1187 gtk_notebook_insert_page (wbcg->snotebook,
1188 GTK_WIDGET (scg->grid), NULL,
1189 pos);
1190 gnm_notebook_insert_tab (wbcg->bnotebook,
1191 GTK_WIDGET (scg->label),
1192 pos);
1193 wbcg_menu_state_sheet_count (wbcg);
1194 wbcg_ui_update_end (wbcg);
1195 }
1196
1197 scg_adjust_preferences (scg);
1198 if (sheet == wb_control_cur_sheet (wbc)) {
1199 scg_take_focus (scg);
1200 wbcg_set_direction (scg);
1201 cb_zoom_change (sheet, NULL, wbcg);
1202 cb_toggle_menu_item_changed (sheet, NULL, wbcg);
1203 }
1204 }
1205
1206 static void
1207 wbcg_sheet_remove (WorkbookControl *wbc, Sheet *sheet)
1208 {
1209 WBCGtk *wbcg = (WBCGtk *)wbc;
1210 SheetControlGUI *scg = wbcg_get_scg (wbcg, sheet);
1211
1212 /* During destruction we may have already removed the notebook */
1213 if (scg == NULL)
1214 return;
1215
1216 disconnect_sheet_signals (scg);
1217
1218 gtk_widget_destroy (GTK_WIDGET (scg->label));
1219 gtk_widget_destroy (GTK_WIDGET (scg->grid));
1220
1221 wbcg_menu_state_sheet_count (wbcg);
1222 }
1223
1224 static void
1225 wbcg_sheet_focus (WorkbookControl *wbc, Sheet *sheet)
1226 {
1227 WBCGtk *wbcg = (WBCGtk *)wbc;
1228 SheetControlGUI *scg = wbcg_get_scg (wbcg, sheet);
1229
1230 if (scg) {
1231 int n = gtk_notebook_page_num (wbcg->snotebook,
1232 GTK_WIDGET (scg->grid));
1233 gnm_notebook_set_current_page (wbcg->bnotebook, n);
1234
1235 if (wbcg->rangesel == NULL)
1236 gnm_expr_entry_set_scg (wbcg->edit_line.entry, scg);
1237 }
1238
1239 disconnect_sheet_focus_signals (wbcg);
1240
1241 if (sheet) {
1242 wbcg_update_menu_feedback (wbcg, sheet);
1243
1244 if (scg)
1245 wbcg_set_direction (scg);
1246
1247 #if 0
1248 g_printerr ("Connecting for %s with scg=%p\n", sheet->name_unquoted, scg);
1249 #endif
1250
1251 g_object_connect
1252 (G_OBJECT (sheet),
1253 "signal::notify::display-formulas", cb_toggle_menu_item_changed, wbcg,
1254 "signal::notify::display-zeros", cb_toggle_menu_item_changed, wbcg,
1255 "signal::notify::display-grid", cb_toggle_menu_item_changed, wbcg,
1256 "signal::notify::display-column-header", cb_toggle_menu_item_changed, wbcg,
1257 "signal::notify::display-row-header", cb_toggle_menu_item_changed, wbcg,
1258 "signal::notify::display-outlines", cb_toggle_menu_item_changed, wbcg,
1259 "signal::notify::display-outlines-below", cb_toggle_menu_item_changed, wbcg,
1260 "signal::notify::display-outlines-right", cb_toggle_menu_item_changed, wbcg,
1261 "signal::notify::text-is-rtl", cb_direction_change, scg,
1262 "signal::notify::zoom-factor", cb_zoom_change, wbcg,
1263 NULL);
1264
1265 wbcg->active_scg = scg;
1266 }
1267 }
1268
1269 static gint
1270 by_sheet_index (gconstpointer a, gconstpointer b)
1271 {
1272 SheetControlGUI *scga = (SheetControlGUI *)a;
1273 SheetControlGUI *scgb = (SheetControlGUI *)b;
1274 return scg_sheet (scga)->index_in_wb - scg_sheet (scgb)->index_in_wb;
1275 }
1276
1277 static void
1278 wbcg_sheet_order_changed (WBCGtk *wbcg)
1279 {
1280 if (wbcg_ui_update_begin (wbcg)) {
1281 GSList *l, *scgs;
1282 int i;
1283
1284 /* Reorder all tabs so they end up in index_in_wb order. */
1285 scgs = g_slist_sort (get_all_scgs (wbcg), by_sheet_index);
1286
1287 for (i = 0, l = scgs; l; l = l->next, i++) {
1288 SheetControlGUI *scg = l->data;
1289 gtk_notebook_reorder_child (wbcg->snotebook,
1290 GTK_WIDGET (scg->grid),
1291 i);
1292 gnm_notebook_move_tab (wbcg->bnotebook,
1293 GTK_WIDGET (scg->label),
1294 i);
1295 }
1296 g_slist_free (scgs);
1297
1298 wbcg_ui_update_end (wbcg);
1299 }
1300 }
1301
1302 static void
1303 wbcg_update_title (WBCGtk *wbcg)
1304 {
1305 GODoc *doc = wb_control_get_doc (GNM_WBC (wbcg));
1306 char *basename = doc->uri ? go_basename_from_uri (doc->uri) : NULL;
1307 char *title = g_strconcat
1308 (go_doc_is_dirty (doc) ? "*" : "",
1309 basename ? basename : doc->uri,
1310 _(" - Gnumeric"),
1311 NULL);
1312 gtk_window_set_title (wbcg_toplevel (wbcg), title);
1313 g_free (title);
1314 g_free (basename);
1315 }
1316
1317 static void
1318 wbcg_sheet_remove_all (WorkbookControl *wbc)
1319 {
1320 WBCGtk *wbcg = (WBCGtk *)wbc;
1321
1322 if (wbcg->snotebook != NULL) {
1323 GtkNotebook *tmp = wbcg->snotebook;
1324 GSList *l, *all = get_all_scgs (wbcg);
1325 SheetControlGUI *current = wbcg_cur_scg (wbcg);
1326
1327 /* Clear notebook to disable updates as focus changes for pages
1328 * during destruction */
1329 wbcg->snotebook = NULL;
1330
1331 /* Be sure we are no longer editing */
1332 wbcg_edit_finish (wbcg, WBC_EDIT_REJECT, NULL);
1333
1334 for (l = all; l; l = l->next) {
1335 SheetControlGUI *scg = l->data;
1336 disconnect_sheet_signals (scg);
1337 if (scg != current) {
1338 gtk_widget_destroy (GTK_WIDGET (scg->label));
1339 gtk_widget_destroy (GTK_WIDGET (scg->grid));
1340 }
1341 }
1342
1343 g_slist_free (all);
1344
1345 /* Do current scg last. */
1346 if (current) {
1347 gtk_widget_destroy (GTK_WIDGET (current->label));
1348 gtk_widget_destroy (GTK_WIDGET (current->grid));
1349 }
1350
1351 wbcg->snotebook = tmp;
1352 }
1353 }
1354
1355 static double
1356 color_diff (const GdkRGBA *a, const GdkRGBA *b)
1357 {
1358 /* Ignoring alpha. */
1359 return ((a->red - b->red) * (a->red - b->red) +
1360 (a->green - b->green) * (a->green - b->green) +
1361 (a->blue - b->blue) * (a->blue - b->blue));
1362 }
1363
1364
1365 static gboolean
1366 cb_adjust_foreground_attributes (PangoAttribute *attribute,
1367 gpointer data)
1368 {
1369 const GdkRGBA *back = data;
1370
1371 if (attribute->klass->type == PANGO_ATTR_FOREGROUND) {
1372 PangoColor *pfore = &((PangoAttrColor *)attribute)->color;
1373 GdkRGBA fore;
1374 const double threshold = 0.01;
1375
1376 fore.red = pfore->red / 65535.0;
1377 fore.green = pfore->green / 65535.0;
1378 fore.blue = pfore->blue / 65535.0;
1379
1380 if (color_diff (&fore, back) < threshold) {
1381 static const GdkRGBA black = { 0, 0, 0, 1 };
1382 static const GdkRGBA white = { 1, 1, 1, 1 };
1383 double back_norm = color_diff (back, &black);
1384 double f = 0.2;
1385 const GdkRGBA *ref =
1386 back_norm > 0.75 ? &black : &white;
1387
1388 #define DO_CHANNEL(channel) \
1389 do { \
1390 double val = fore.channel * (1 - f) + ref->channel * f; \
1391 pfore->channel = CLAMP (val, 0, 1) * 65535; \
1392 } while (0)
1393 DO_CHANNEL(red);
1394 DO_CHANNEL(green);
1395 DO_CHANNEL(blue);
1396 #undef DO_CHANNEL
1397 }
1398 }
1399 return FALSE;
1400 }
1401
1402 static void
1403 adjust_foreground_attributes (PangoAttrList *attrs, GtkWidget *w)
1404 {
1405 GdkRGBA c;
1406 GtkStyleContext *ctxt = gtk_widget_get_style_context (w);
1407
1408 gtk_style_context_get_background_color (ctxt, GTK_STATE_FLAG_NORMAL,
1409 &c);
1410
1411 if (0)
1412 g_printerr ("back=%s\n", gdk_rgba_to_string (&c));
1413
1414 pango_attr_list_unref
1415 (pango_attr_list_filter
1416 (attrs,
1417 cb_adjust_foreground_attributes,
1418 &c));
1419 }
1420
1421
1422 static void
1423 wbcg_auto_expr_value_changed (WorkbookView *wbv,
1424 G_GNUC_UNUSED GParamSpec *pspec,
1425 WBCGtk *wbcg)
1426 {
1427 GtkLabel *lbl = GTK_LABEL (wbcg->auto_expr_label);
1428 GnmValue const *v = wbv->auto_expr.value;
1429
1430 if (v) {
1431 GOFormat const *format = VALUE_FMT (v);
1432 GString *str = g_string_new (wbv->auto_expr.descr);
1433 PangoAttrList *attrs = NULL;
1434
1435 g_string_append (str, " = ");
1436
1437 if (format) {
1438 PangoLayout *layout = gtk_widget_create_pango_layout (GTK_WIDGET (wbcg->toplevel), NULL);
1439 gsize old_len = str->len;
1440 GODateConventions const *date_conv = workbook_date_conv (wb_view_get_workbook (wbv));
1441 GOFormatNumberError err =
1442 format_value_layout (layout, format, v,
1443 strlen (AUTO_EXPR_SAMPLE) - g_utf8_strlen (str->str, -1),
1444 date_conv);
1445 switch (err) {
1446 case GO_FORMAT_NUMBER_OK:
1447 case GO_FORMAT_NUMBER_DATE_ERROR: {
1448 PangoAttrList *atl;
1449
1450 go_pango_translate_layout (layout); /* translating custom attributes */
1451 g_string_append (str, pango_layout_get_text (layout));
1452 /* We need to shift the attribute list */
1453 atl = pango_attr_list_ref (pango_layout_get_attributes (layout));
1454 if (atl != NULL) {
1455 attrs = pango_attr_list_new ();
1456 pango_attr_list_splice
1457 (attrs, atl, old_len,
1458 str->len - old_len);
1459 pango_attr_list_unref (atl);
1460 /* Adjust colours to make text visible. */
1461 adjust_foreground_attributes
1462 (attrs,
1463 gtk_widget_get_parent (GTK_WIDGET (lbl)));
1464 }
1465 break;
1466 }
1467 default:
1468 case GO_FORMAT_NUMBER_INVALID_FORMAT:
1469 g_string_append (str, _("Invalid format"));
1470 break;
1471 }
1472 g_object_unref (layout);
1473 } else
1474 g_string_append (str, value_peek_string (v));
1475
1476 gtk_label_set_text (lbl, str->str);
1477 gtk_label_set_attributes (lbl, attrs);
1478
1479 pango_attr_list_unref (attrs);
1480 g_string_free (str, TRUE);
1481 } else {
1482 gtk_label_set_text (lbl, "");
1483 gtk_label_set_attributes (lbl, NULL);
1484 }
1485 }
1486
1487 static void
1488 wbcg_scrollbar_visibility (WorkbookView *wbv,
1489 G_GNUC_UNUSED GParamSpec *pspec,
1490 WBCGtk *wbcg)
1491 {
1492 SheetControlGUI *scg = wbcg_cur_scg (wbcg);
1493 scg_adjust_preferences (scg);
1494 }
1495
1496 static void
1497 wbcg_notebook_tabs_visibility (WorkbookView *wbv,
1498 G_GNUC_UNUSED GParamSpec *pspec,
1499 WBCGtk *wbcg)
1500 {
1501 gtk_widget_set_visible (GTK_WIDGET (wbcg->bnotebook),
1502 wbv->show_notebook_tabs);
1503 }
1504
1505
1506 static void
1507 wbcg_menu_state_update (WorkbookControl *wbc, int flags)
1508 {
1509 WBCGtk *wbcg = (WBCGtk *)wbc;
1510 SheetControlGUI *scg = wbcg_cur_scg (wbcg);
1511 SheetView const *sv = wb_control_cur_sheet_view (wbc);
1512 Sheet const *sheet = wb_control_cur_sheet (wbc);
1513 gboolean const has_guru = wbc_gtk_get_guru (wbcg) != NULL;
1514 gboolean edit_object = scg != NULL &&
1515 (scg->selected_objects != NULL || wbcg->new_object != NULL);
1516 gboolean has_print_area;
1517
1518 if (MS_INSERT_COLS & flags)
1519 wbc_gtk_set_action_sensitivity (wbcg, "InsertColumns",
1520 sv->enable_insert_cols);
1521 if (MS_INSERT_ROWS & flags)
1522 wbc_gtk_set_action_sensitivity (wbcg, "InsertRows",
1523 sv->enable_insert_rows);
1524 if (MS_INSERT_CELLS & flags)
1525 wbc_gtk_set_action_sensitivity (wbcg, "InsertCells",
1526 sv->enable_insert_cells);
1527 if (MS_SHOWHIDE_DETAIL & flags) {
1528 wbc_gtk_set_action_sensitivity (wbcg, "DataOutlineShowDetail",
1529 sheet->priv->enable_showhide_detail);
1530 wbc_gtk_set_action_sensitivity (wbcg, "DataOutlineHideDetail",
1531 sheet->priv->enable_showhide_detail);
1532 }
1533 if (MS_PASTE_SPECIAL & flags)
1534 wbc_gtk_set_action_sensitivity (wbcg, "EditPasteSpecial",
1535 // Inter-process paste special is now allowed
1536 !gnm_app_clipboard_is_cut () &&
1537 !edit_object);
1538 if (MS_PRINT_SETUP & flags)
1539 wbc_gtk_set_action_sensitivity (wbcg, "FilePageSetup", !has_guru);
1540 if (MS_SEARCH_REPLACE & flags)
1541 wbc_gtk_set_action_sensitivity (wbcg, "EditReplace", !has_guru);
1542 if (MS_DEFINE_NAME & flags) {
1543 wbc_gtk_set_action_sensitivity (wbcg, "EditNames", !has_guru);
1544 wbc_gtk_set_action_sensitivity (wbcg, "InsertNames", !has_guru);
1545 }
1546 if (MS_CONSOLIDATE & flags)
1547 wbc_gtk_set_action_sensitivity (wbcg, "DataConsolidate", !has_guru);
1548 if (MS_FILTER_STATE_CHANGED & flags)
1549 wbc_gtk_set_action_sensitivity (wbcg, "DataFilterShowAll", sheet->has_filtered_rows);
1550 if (MS_SHOW_PRINTAREA & flags) {
1551 GnmRange *print_area = sheet_get_nominal_printarea (sheet);
1552 has_print_area = (print_area != NULL);
1553 g_free (print_area);
1554 wbc_gtk_set_action_sensitivity (wbcg, "FilePrintAreaClear", has_print_area);
1555 wbc_gtk_set_action_sensitivity (wbcg, "FilePrintAreaShow", has_print_area);
1556 }
1557 if (MS_PAGE_BREAKS & flags) {
1558 gint col = sv->edit_pos.col;
1559 gint row = sv->edit_pos.row;
1560 GnmPrintInformation *pi = sheet->print_info;
1561 char const* new_label = NULL;
1562 char const *new_tip = NULL;
1563
1564 if (pi->page_breaks.v != NULL &&
1565 gnm_page_breaks_get_break (pi->page_breaks.v, col) == GNM_PAGE_BREAK_MANUAL) {
1566 new_label = _("Remove Column Page Break");
1567 new_tip = _("Remove the page break to the left of the current column");
1568 } else {
1569 new_label = _("Add Column Page Break");
1570 new_tip = _("Add a page break to the left of the current column");
1571 }
1572 wbc_gtk_set_action_label (wbcg, "FilePrintAreaToggleColPageBreak",
1573 NULL, new_label, new_tip);
1574 if (pi->page_breaks.h != NULL &&
1575 gnm_page_breaks_get_break (pi->page_breaks.h, col) == GNM_PAGE_BREAK_MANUAL) {
1576 new_label = _("Remove Row Page Break");
1577 new_tip = _("Remove the page break above the current row");
1578 } else {
1579 new_label = _("Add Row Page Break");
1580 new_tip = _("Add a page break above current row");
1581 }
1582 wbc_gtk_set_action_label (wbcg, "FilePrintAreaToggleRowPageBreak",
1583 NULL, new_label, new_tip);
1584 wbc_gtk_set_action_sensitivity (wbcg, "FilePrintAreaToggleRowPageBreak",
1585 row != 0);
1586 wbc_gtk_set_action_sensitivity (wbcg, "FilePrintAreaToggleColPageBreak",
1587 col != 0);
1588 wbc_gtk_set_action_sensitivity (wbcg, "FilePrintAreaClearAllPageBreak",
1589 print_info_has_manual_breaks (sheet->print_info));
1590 }
1591 if (MS_SELECT_OBJECT & flags) {
1592 wbc_gtk_set_action_sensitivity (wbcg, "EditSelectObject",
1593 sheet->sheet_objects != NULL);
1594 }
1595
1596 if (MS_FREEZE_VS_THAW & flags) {
1597 /* Cheat and use the same accelerator for both states because
1598 * we don't reset it when the label changes */
1599 char const* label = gnm_sheet_view_is_frozen (sv)
1600 ? _("Un_freeze Panes")
1601 : _("_Freeze Panes");
1602 char const *new_tip = gnm_sheet_view_is_frozen (sv)
1603 ? _("Unfreeze the top left of the sheet")
1604 : _("Freeze the top left of the sheet");
1605 wbc_gtk_set_action_label (wbcg, "ViewFreezeThawPanes", NULL, label, new_tip);
1606 }
1607
1608 if (MS_ADD_VS_REMOVE_FILTER & flags) {
1609 gboolean const has_filter = (NULL != gnm_sheet_view_editpos_in_filter (sv));
1610 GnmFilter *f = gnm_sheet_view_selection_intersects_filter_rows (sv);
1611 char const* label;
1612 char const *new_tip;
1613 gboolean active = TRUE;
1614 GnmRange *r = NULL;
1615
1616 if ((!has_filter) && (NULL != f)) {
1617 gchar *nlabel = NULL;
1618 if (NULL != (r = gnm_sheet_view_selection_extends_filter (sv, f))) {
1619 active = TRUE;
1620 nlabel = g_strdup_printf
1621 (_("Extend _Auto Filter to %s"),
1622 range_as_string (r));
1623 new_tip = _("Extend the existing filter.");
1624 wbc_gtk_set_action_label
1625 (wbcg, "DataAutoFilter", NULL,
1626 nlabel, new_tip);
1627 g_free (r);
1628 } else {
1629 active = FALSE;
1630 nlabel = g_strdup_printf
1631 (_("Auto Filter blocked by %s"),
1632 range_as_string (&f->r));
1633 new_tip = _("The selection intersects an "
1634 "existing auto filter.");
1635 wbc_gtk_set_action_label
1636 (wbcg, "DataAutoFilter", NULL,
1637 nlabel, new_tip);
1638 }
1639 g_free (nlabel);
1640 } else {
1641 label = has_filter
1642 ? _("Remove _Auto Filter")
1643 : _("Add _Auto Filter");
1644 new_tip = has_filter
1645 ? _("Remove a filter")
1646 : _("Add a filter");
1647 wbc_gtk_set_action_label (wbcg, "DataAutoFilter", NULL, label, new_tip);
1648 }
1649
1650 wbc_gtk_set_action_sensitivity (wbcg, "DataAutoFilter", active);
1651 }
1652 if (MS_COMMENT_LINKS & flags) {
1653 gboolean has_comment
1654 = (sheet_get_comment (sheet, &sv->edit_pos) != NULL);
1655 gboolean has_link;
1656 GnmRange rge;
1657 range_init_cellpos (&rge, &sv->edit_pos);
1658 has_link = (NULL !=
1659 sheet_style_region_contains_link (sheet, &rge));
1660 wbc_gtk_set_action_sensitivity
1661 (wbcg, "EditComment", has_comment);
1662 wbc_gtk_set_action_sensitivity
1663 (wbcg, "EditHyperlink", has_link);
1664 }
1665
1666 if (MS_COMMENT_LINKS_RANGE & flags) {
1667 GSList *l;
1668 int count = 0;
1669 gboolean has_links = FALSE, has_comments = FALSE;
1670 gboolean sel_is_vector = FALSE;
1671 SheetView *sv = scg_view (scg);
1672 for (l = sv->selections;
1673 l != NULL; l = l->next) {
1674 GnmRange const *r = l->data;
1675 GSList *objs;
1676 GnmStyleList *styles;
1677 if (!has_links) {
1678 styles = sheet_style_collect_hlinks
1679 (sheet, r);
1680 has_links = (styles != NULL);
1681 style_list_free (styles);
1682 }
1683 if (!has_comments) {
1684 objs = sheet_objects_get
1685 (sheet, r, GNM_CELL_COMMENT_TYPE);
1686 has_comments = (objs != NULL);
1687 g_slist_free (objs);
1688 }
1689 if((count++ > 1) && has_comments && has_links)
1690 break;
1691 }
1692 wbc_gtk_set_action_sensitivity
1693 (wbcg, "EditClearHyperlinks", has_links);
1694 wbc_gtk_set_action_sensitivity
1695 (wbcg, "EditClearComments", has_comments);
1696 if (count == 1) {
1697 GnmRange const *r = sv->selections->data;
1698 sel_is_vector = (range_width (r) == 1 ||
1699 range_height (r) == 1) &&
1700 !range_is_singleton (r);
1701 }
1702 wbc_gtk_set_action_sensitivity
1703 (wbcg, "InsertSortDecreasing", sel_is_vector);
1704 wbc_gtk_set_action_sensitivity
1705 (wbcg, "InsertSortIncreasing", sel_is_vector);
1706 }
1707 if (MS_FILE_EXPORT_IMPORT & flags) {
1708 Workbook *wb = wb_control_get_workbook (wbc);
1709 gboolean has_export_info = workbook_get_file_exporter (wb) &&
1710 workbook_get_last_export_uri (wb);
1711 wbc_gtk_set_action_sensitivity (wbcg, "DataExportRepeat", has_export_info);
1712 if (has_export_info) {
1713 gchar *base = go_basename_from_uri (workbook_get_last_export_uri (wb));
1714 gchar *new_label = g_strdup_printf (_("Repeat Export to %s"),
1715 base);
1716 g_free (base);
1717 wbc_gtk_set_action_label (wbcg, "DataExportRepeat", NULL,
1718 new_label, N_("Repeat the last data export"));
1719 g_free (new_label);
1720 } else
1721 wbc_gtk_set_action_label (wbcg, "DataExportRepeat", NULL,
1722 N_("Repeat Export"), N_("Repeat the last data export"));
1723 }
1724 {
1725 gboolean const has_slicer = (NULL != gnm_sheet_view_editpos_in_slicer (sv));
1726 char const* label = has_slicer
1727 ? _("Remove _Data Slicer")
1728 : _("Create _Data Slicer");
1729 char const *new_tip = has_slicer
1730 ? _("Remove a Data Slicer")
1731 : _("Create a Data Slicer");
1732 wbc_gtk_set_action_label (wbcg, "DataSlicer", NULL, label, new_tip);
1733 wbc_gtk_set_action_sensitivity (wbcg, "DataSlicerRefresh", has_slicer);
1734 wbc_gtk_set_action_sensitivity (wbcg, "DataSlicerEdit", has_slicer);
1735 }
1736 }
1737
1738 static void
1739 wbcg_undo_redo_labels (WorkbookControl *wbc, char const *undo, char const *redo)
1740 {
1741 WBCGtk *wbcg = (WBCGtk *)wbc;
1742 g_return_if_fail (wbcg != NULL);
1743
1744 wbc_gtk_set_action_label (wbcg, "Redo", _("_Redo"), redo, NULL);
1745 wbc_gtk_set_action_label (wbcg, "Undo", _("_Undo"), undo, NULL);
1746 wbc_gtk_set_action_sensitivity (wbcg, "Repeat", undo != NULL);
1747 }
1748
1749 static void
1750 wbcg_paste_from_selection (WorkbookControl *wbc, GnmPasteTarget const *pt)
1751 {
1752 gnm_x_request_clipboard ((WBCGtk *)wbc, pt);
1753 }
1754
1755 static gboolean
1756 wbcg_claim_selection (WorkbookControl *wbc)
1757 {
1758 WBCGtk *wbcg = (WBCGtk *)wbc;
1759 GdkDisplay *display = gtk_widget_get_display (GTK_WIDGET (wbcg_toplevel (wbcg)));
1760 return gnm_x_claim_clipboard (display);
1761 }
1762
1763 static int
1764 wbcg_show_save_dialog (WBCGtk *wbcg, Workbook *wb)
1765 {
1766 GtkWidget *d;
1767 char *msg;
1768 char const *wb_uri = go_doc_get_uri (GO_DOC (wb));
1769 int ret = 0;
1770
1771 if (wb_uri) {
1772 char *base = go_basename_from_uri (wb_uri);
1773 char *display = g_markup_escape_text (base, -1);
1774 msg = g_strdup_printf (
1775 _("Save changes to workbook '%s' before closing?"),
1776 display);
1777 g_free (base);
1778 g_free (display);
1779 } else {
1780 msg = g_strdup (_("Save changes to workbook before closing?"));
1781 }
1782
1783 d = gnm_message_dialog_create (wbcg_toplevel (wbcg),
1784 GTK_DIALOG_DESTROY_WITH_PARENT,
1785 GTK_MESSAGE_WARNING,
1786 msg,
1787 _("If you close without saving, changes will be discarded."));
1788 atk_object_set_role (gtk_widget_get_accessible (d), ATK_ROLE_ALERT);
1789
1790 go_gtk_dialog_add_button (GTK_DIALOG(d), _("Discard"),
1791 GTK_STOCK_DELETE, GTK_RESPONSE_NO);
1792 go_gtk_dialog_add_button (GTK_DIALOG(d), _("Don't close"),
1793 GNM_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
1794
1795 gtk_dialog_add_button (GTK_DIALOG(d), GNM_STOCK_SAVE, GTK_RESPONSE_YES);
1796 gtk_dialog_set_default_response (GTK_DIALOG (d), GTK_RESPONSE_YES);
1797 ret = go_gtk_dialog_run (GTK_DIALOG (d), wbcg_toplevel (wbcg));
1798 g_free (msg);
1799
1800 return ret;
1801 }
1802
1803 /*
1804 * wbcg_close_if_user_permits : If the workbook is dirty the user is
1805 * prompted to see if they should exit.
1806 *
1807 * Returns:
1808 * 0) canceled
1809 * 1) closed
1810 * 2) -
1811 * 3) save any future dirty
1812 * 4) do not save any future dirty
1813 */
1814 static int
1815 wbcg_close_if_user_permits (WBCGtk *wbcg, WorkbookView *wb_view)
1816 {
1817 gboolean can_close = TRUE;
1818 gboolean done = FALSE;
1819 int iteration = 0;
1820 int button = 0;
1821 Workbook *wb = wb_view_get_workbook (wb_view);
1822 static int in_can_close;
1823
1824 g_return_val_if_fail (GNM_IS_WORKBOOK (wb), 0);
1825
1826 if (in_can_close)
1827 return 0;
1828 in_can_close = TRUE;
1829
1830 while (go_doc_is_dirty (GO_DOC (wb)) && !done) {
1831 iteration++;
1832 button = wbcg_show_save_dialog(wbcg, wb);
1833
1834 switch (button) {
1835 case GTK_RESPONSE_YES:
1836 done = gui_file_save (wbcg, wb_view);
1837 break;
1838
1839 case GNM_RESPONSE_SAVE_ALL:
1840 done = gui_file_save (wbcg, wb_view);
1841 break;
1842
1843 case GTK_RESPONSE_NO:
1844 done = TRUE;
1845 go_doc_set_dirty (GO_DOC (wb), FALSE);
1846 break;
1847
1848 case GNM_RESPONSE_DISCARD_ALL:
1849 done = TRUE;
1850 go_doc_set_dirty (GO_DOC (wb), FALSE);
1851 break;
1852
1853 default: /* CANCEL */
1854 can_close = FALSE;
1855 done = TRUE;
1856 break;
1857 }
1858 }
1859
1860 in_can_close = FALSE;
1861
1862 if (can_close) {
1863 gnm_x_store_clipboard_if_needed (wb);
1864 g_object_unref (wb);
1865 switch (button) {
1866 case GNM_RESPONSE_SAVE_ALL:
1867 return 3;
1868 case GNM_RESPONSE_DISCARD_ALL:
1869 return 4;
1870 default:
1871 return 1;
1872 }
1873 } else
1874 return 0;
1875 }
1876
1877 /**
1878 * wbc_gtk_close:
1879 * @wbcg: #WBCGtk
1880 *
1881 * Returns TRUE if the control should NOT be closed.
1882 */
1883 gboolean
1884 wbc_gtk_close (WBCGtk *wbcg)
1885 {
1886 WorkbookView *wb_view = wb_control_view (GNM_WBC (wbcg));
1887
1888 g_return_val_if_fail (GNM_IS_WORKBOOK_VIEW (wb_view), TRUE);
1889 g_return_val_if_fail (wb_view->wb_controls != NULL, TRUE);
1890
1891 /* If we were editing when the quit request came make sure we don't
1892 * lose any entered text
1893 */
1894 if (!wbcg_edit_finish (wbcg, WBC_EDIT_ACCEPT, NULL))
1895 return TRUE;
1896
1897 /* If something is still using the control
1898 * eg progress meter for a new book */
1899 if (G_OBJECT (wbcg)->ref_count > 1)
1900 return TRUE;
1901
1902 /* This is the last control */
1903 if (wb_view->wb_controls->len <= 1) {
1904 Workbook *wb = wb_view_get_workbook (wb_view);
1905
1906 g_return_val_if_fail (GNM_IS_WORKBOOK (wb), TRUE);
1907 g_return_val_if_fail (wb->wb_views != NULL, TRUE);
1908
1909 /* This is the last view */
1910 if (wb->wb_views->len <= 1) {
1911 if (wbcg_close_if_user_permits (wbcg, wb_view) == 0)
1912 return TRUE;
1913 return FALSE;
1914 }
1915
1916 g_object_unref (wb_view);
1917 } else
1918 g_object_unref (wbcg);
1919
1920 _gnm_app_flag_windows_changed ();
1921
1922 return FALSE;
1923 }
1924
1925 static void
1926 cb_cancel_input (WBCGtk *wbcg)
1927 {
1928 wbcg_edit_finish (wbcg, WBC_EDIT_REJECT, NULL);
1929 }
1930
1931 static void
1932 cb_accept_input (WBCGtk *wbcg)
1933 {
1934 wbcg_edit_finish (wbcg, WBC_EDIT_ACCEPT, NULL);
1935 }
1936
1937 static void
1938 cb_accept_input_wo_ac (WBCGtk *wbcg)
1939 {
1940 wbcg_edit_finish (wbcg, WBC_EDIT_ACCEPT_WO_AC, NULL);
1941 }
1942
1943 static void
1944 cb_accept_input_array (WBCGtk *wbcg)
1945 {
1946 wbcg_edit_finish (wbcg, WBC_EDIT_ACCEPT_ARRAY, NULL);
1947 }
1948
1949 static void
1950 cb_accept_input_selected_cells (WBCGtk *wbcg)
1951 {
1952 wbcg_edit_finish (wbcg, WBC_EDIT_ACCEPT_RANGE, NULL);
1953 }
1954
1955 static void
1956 cb_accept_input_selected_merged (WBCGtk *wbcg)
1957 {
1958 Sheet *sheet = wbcg->editing_sheet;
1959
1960 #warning FIXME: this creates 2 undo items!
1961 if (wbcg_is_editing (wbcg) &&
1962 wbcg_edit_finish (wbcg, WBC_EDIT_ACCEPT, NULL)) {
1963 WorkbookControl *wbc = GNM_WBC (wbcg);
1964 WorkbookView *wbv = wb_control_view (wbc);
1965 SheetView *sv = sheet_get_view (sheet, wbv);
1966 GnmRange sel = *(selection_first_range (sv, NULL, NULL));
1967 GSList *selection = g_slist_prepend (NULL, &sel);
1968
1969 cmd_merge_cells (wbc, sheet, selection, FALSE);
1970 g_slist_free (selection);
1971 }
1972 }
1973
1974 /* static void */
1975 /* cb_accept_input_sheets_collector (Sheet *sheet, GSList **n) */
1976 /* { */
1977 /* if (sheet->visibility == GNM_SHEET_VISIBILITY_VISIBLE) */
1978 /* (*n) = g_slist_prepend (*n, sheet); */
1979 /* } */
1980
1981 /* static void */
1982 /* cb_accept_input_sheets (WBCGtk *wbcg) */
1983 /* { */
1984 /* GSList *sheets = workbook_sheets */
1985 /* (wb_control_get_workbook (GNM_WBC (wbcg))); */
1986 /* GSList *vis_sheets = NULL; */
1987
1988 /* g_slist_foreach (sheets, */
1989 /* (GFunc) cb_accept_input_sheets_collector, */
1990 /* &vis_sheets); */
1991
1992 /* wbcg_edit_multisheet_finish (wbcg, WBC_EDIT_ACCEPT, NULL, vis_sheets); */
1993
1994 /* g_slist_free (sheets); */
1995 /* g_slist_free (vis_sheets); */
1996 /* } */
1997
1998 /* static void */
1999 /* cb_accept_input_menu_sensitive_sheets_counter (Sheet *sheet, gint *n) */
2000 /* { */
2001 /* if (sheet->visibility == GNM_SHEET_VISIBILITY_VISIBLE) */
2002 /* (*n)++; */
2003 /* } */
2004
2005 /* static gboolean */
2006 /* cb_accept_input_menu_sensitive_sheets (WBCGtk *wbcg) */
2007 /* { */
2008 /* GSList *sheets = workbook_sheets */
2009 /* (wb_control_get_workbook (GNM_WBC (wbcg))); */
2010 /* gint n = 0; */
2011
2012 /* g_slist_foreach (sheets, */
2013 /* (GFunc) cb_accept_input_menu_sensitive_sheets_counter, */
2014 /* &n); */
2015 /* g_slist_free (sheets); */
2016 /* return (n > 1); */
2017 /* } */
2018
2019 /* static gboolean */
2020 /* cb_accept_input_menu_sensitive_selected_sheets (WBCGtk *wbcg) */
2021 /* { */
2022 /* GSList *sheets = workbook_sheets */
2023 /* (wb_control_get_workbook (GNM_WBC (wbcg))); */
2024 /* gint n = 0; */
2025
2026 /* g_slist_foreach (sheets, */
2027 /* (GFunc) cb_accept_input_menu_sensitive_sheets_counter, */
2028 /* &n); */
2029 /* g_slist_free (sheets); */
2030 /* return (n > 2); */
2031 /* } */
2032
2033 static gboolean
2034 cb_accept_input_menu_sensitive_selected_cells (WBCGtk *wbcg)
2035 {
2036 WorkbookControl *wbc = GNM_WBC (wbcg);
2037 WorkbookView *wbv = wb_control_view (wbc);
2038 SheetView *sv = sheet_get_view (wbcg->editing_sheet, wbv);
2039 gboolean result = TRUE;
2040 GSList *selection = selection_get_ranges (sv, FALSE), *l;
2041
2042 for (l = selection; l != NULL; l = l->next) {
2043 GnmRange const *sel = l->data;
2044 if (sheet_range_splits_array
2045 (wbcg->editing_sheet, sel, NULL, NULL, NULL)) {
2046 result = FALSE;
2047 break;
2048 }
2049 }
2050 range_fragment_free (selection);
2051 return result;
2052 }
2053
2054 static gboolean
2055 cb_accept_input_menu_sensitive_selected_merged (WBCGtk *wbcg)
2056 {
2057 WorkbookControl *wbc = GNM_WBC (wbcg);
2058 WorkbookView *wbv = wb_control_view (wbc);
2059 SheetView *sv = sheet_get_view (wbcg->editing_sheet, wbv);
2060 GnmRange const *sel = selection_first_range (sv, NULL, NULL);
2061
2062 return (sel && !range_is_singleton (sel) &&
2063 sv->edit_pos.col == sel->start.col &&
2064 sv->edit_pos.row == sel->start.row &&
2065 !sheet_range_splits_array
2066 (wbcg->editing_sheet, sel, NULL, NULL, NULL));
2067 }
2068
2069 static void
2070 cb_accept_input_menu (GtkMenuToolButton *button, WBCGtk *wbcg)
2071 {
2072 GtkWidget *menu = gtk_menu_tool_button_get_menu (button);
2073 GList *l, *children = gtk_container_get_children (GTK_CONTAINER (menu));
2074
2075 struct AcceptInputMenu {
2076 gchar const *text;
2077 void (*function) (WBCGtk *wbcg);
2078 gboolean (*sensitive) (WBCGtk *wbcg);
2079 } const accept_input_actions [] = {
2080 { N_("Enter in current cell"), cb_accept_input,
2081 NULL },
2082 { N_("Enter in current cell without autocorrection"), cb_accept_input_wo_ac,
2083 NULL },
2084 /* { N_("Enter on all non-hidden sheets"), cb_accept_input_sheets, */
2085 /* cb_accept_input_menu_sensitive_sheets}, */
2086 /* { N_("Enter on multiple sheets..."), cb_accept_input_selected_sheets, */
2087 /* cb_accept_input_menu_sensitive_selected_sheets }, */
2088 { NULL, NULL, NULL },
2089 { N_("Enter in current range merged"), cb_accept_input_selected_merged,
2090 cb_accept_input_menu_sensitive_selected_merged },
2091 { NULL, NULL, NULL },
2092 { N_("Enter in selected ranges"), cb_accept_input_selected_cells,
2093 cb_accept_input_menu_sensitive_selected_cells },
2094 { N_("Enter in selected ranges as array"), cb_accept_input_array,
2095 cb_accept_input_menu_sensitive_selected_cells },
2096 };
2097 unsigned int ui;
2098 GtkWidget *item;
2099 const struct AcceptInputMenu *it;
2100
2101 if (children == NULL)
2102 for (ui = 0; ui < G_N_ELEMENTS (accept_input_actions); ui++) {
2103 it = accept_input_actions + ui;
2104
2105 if (it->text) {
2106 item = gtk_image_menu_item_new_with_label
2107 (_(it->text));
2108 if (it->function)
2109 g_signal_connect_swapped
2110 (G_OBJECT (item), "activate",
2111 G_CALLBACK (it->function),
2112 wbcg);
2113 if (wbcg->editing_sheet) {
2114 if (it->sensitive)
2115 gtk_widget_set_sensitive
2116 (item, (it->sensitive) (wbcg));
2117 else
2118 gtk_widget_set_sensitive (item, TRUE);
2119 } else
2120 gtk_widget_set_sensitive (item, FALSE);
2121 } else
2122 item = gtk_separator_menu_item_new ();
2123 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
2124 gtk_widget_show (item);
2125 }
2126 else
2127 for (ui = 0, l = children;
2128 ui < G_N_ELEMENTS (accept_input_actions) && l != NULL;
2129 ui++, l = l->next) {
2130 it = accept_input_actions + ui;
2131 if (wbcg->editing_sheet) {
2132 if (it->sensitive)
2133 gtk_widget_set_sensitive
2134 (GTK_WIDGET (l->data),
2135 (it->sensitive) (wbcg));
2136 else
2137 gtk_widget_set_sensitive
2138 (GTK_WIDGET (l->data), TRUE);
2139 } else
2140 gtk_widget_set_sensitive (l->data, FALSE);
2141 }
2142
2143
2144 g_list_free (children);
2145 }
2146
2147 static gboolean
2148 cb_editline_focus_in (GtkWidget *w, GdkEventFocus *event,
2149 WBCGtk *wbcg)
2150 {
2151 if (!wbcg_is_editing (wbcg))
2152 if (!wbcg_edit_start (wbcg, FALSE, TRUE)) {
2153 #if 0
2154 GtkEntry *entry = GTK_ENTRY (w);
2155 #endif
2156 wbcg_focus_cur_scg (wbcg);
2157 #warning GTK3: what can we do there for gtk3?
2158 #if 0
2159 entry->in_drag = FALSE;
2160 /*
2161 * ->button is private, ugh. Since the text area
2162 * never gets a release event, there seems to be
2163 * no official way of returning the widget to its
2164 * correct state.
2165 */
2166 entry->button = 0;
2167 #endif
2168 return TRUE;
2169 }
2170
2171 return FALSE;
2172 }
2173
2174 static void
2175 cb_statusbox_activate (GtkEntry *entry, WBCGtk *wbcg)
2176 {
2177 WorkbookControl *wbc = GNM_WBC (wbcg);
2178 wb_control_parse_and_jump (wbc, gtk_entry_get_text (entry));
2179 wbcg_focus_cur_scg (wbcg);
2180 wb_view_selection_desc (wb_control_view (wbc), TRUE, wbc);
2181 }
2182
2183 static gboolean
2184 cb_statusbox_focus (GtkEntry *entry, GdkEventFocus *event,
2185 WBCGtk *wbcg)
2186 {
2187 gtk_editable_select_region (GTK_EDITABLE (entry), 0, 0);
2188 return FALSE;
2189 }
2190
2191 /******************************************************************************/
2192
2193 static void
2194 dump_size_tree (GtkWidget *w, gpointer indent_)
2195 {
2196 int indent = GPOINTER_TO_INT (indent_);
2197 int h1, h2;
2198 GtkAllocation a;
2199
2200 g_printerr ("%*s", indent, "");
2201 if (gtk_widget_get_name (w))
2202 g_printerr ("\"%s\" ", gtk_widget_get_name (w));
2203
2204 gtk_widget_get_preferred_height (w, &h1, &h2);
2205 gtk_widget_get_allocation (w, &a);
2206
2207 g_printerr ("%s %p viz=%d act=%dx%d minheight=%d natheight=%d\n",
2208 g_type_name_from_instance ((GTypeInstance *)w), w,
2209 gtk_widget_get_visible (w),
2210 a.width, a.height,
2211 h1, h2);
2212
2213 if (GTK_IS_CONTAINER (w)) {
2214 gtk_container_foreach (GTK_CONTAINER (w),
2215 dump_size_tree,
2216 GINT_TO_POINTER (indent + 2));
2217 }
2218 }
2219
2220
2221 static void
2222 cb_workbook_debug_info (WBCGtk *wbcg)
2223 {
2224 Workbook *wb = wb_control_get_workbook (GNM_WBC (wbcg));
2225
2226 if (gnm_debug_flag ("notebook-size"))
2227 dump_size_tree (GTK_WIDGET (wbcg_toplevel (wbcg)), GINT_TO_POINTER (0));
2228
2229 if (gnm_debug_flag ("deps")) {
2230 dependents_dump (wb);
2231 }
2232
2233 if (gnm_debug_flag ("expr-sharer")) {
2234 GnmExprSharer *es = workbook_share_expressions (wb, FALSE);
2235 gnm_expr_sharer_report (es);
2236 gnm_expr_sharer_destroy (es);
2237 }
2238
2239 if (gnm_debug_flag ("style-optimize")) {
2240 workbook_optimize_style (wb);
2241 }
2242
2243 if (gnm_debug_flag ("name-collections")) {
2244 gnm_named_expr_collection_dump (wb->names, "workbook");
2245 WORKBOOK_FOREACH_SHEET(wb, sheet, {
2246 gnm_named_expr_collection_dump (sheet->names,
2247 sheet->name_unquoted);
2248 });
2249 }
2250 }
2251
2252 static void
2253 cb_autofunction (WBCGtk *wbcg)
2254 {
2255 GtkEntry *entry;
2256 gchar const *txt;
2257
2258 if (wbcg_is_editing (wbcg))
2259 return;
2260
2261 entry = wbcg_get_entry (wbcg);
2262 txt = gtk_entry_get_text (entry);
2263 if (strncmp (txt, "=", 1)) {
2264 if (!wbcg_edit_start (wbcg, TRUE, TRUE))
2265 return; /* attempt to edit failed */
2266 gtk_entry_set_text (entry, "=");
2267 gtk_editable_set_position (GTK_EDITABLE (entry), 1);
2268 } else {
2269 if (!wbcg_edit_start (wbcg, FALSE, TRUE))
2270 return; /* attempt to edit failed */
2271
2272 /* FIXME : This is crap!
2273 * When the function druid is more complete use that.
2274 */
2275 gtk_editable_set_position (GTK_EDITABLE (entry),
2276 gtk_entry_get_text_length (entry)-1);
2277 }
2278 }
2279
2280 /*
2281 * We must not crash on focus=NULL. We're called like that as a result of
2282 * gtk_window_set_focus (toplevel, NULL) if the first sheet view is destroyed
2283 * just after being created. This happens e.g when we cancel a file import or
2284 * the import fails.
2285 */
2286 static void
2287 cb_set_focus (GtkWindow *window, GtkWidget *focus, WBCGtk *wbcg)
2288 {
2289 if (focus && !gtk_window_get_focus (window))
2290 wbcg_focus_cur_scg (wbcg);
2291 }
2292
2293 /***************************************************************************/
2294
2295 static gboolean
2296 cb_scroll_wheel (GtkWidget *w, GdkEventScroll *event,
2297 WBCGtk *wbcg)
2298 {
2299 SheetControlGUI *scg = wbcg_get_scg (wbcg, wbcg_focus_cur_scg (wbcg));
2300 Sheet *sheet = scg_sheet (scg);
2301 /* scroll always operates on pane 0 */
2302 GnmPane *pane = scg_pane (scg, 0);
2303 gboolean go_horiz = (event->direction == GDK_SCROLL_LEFT ||
2304 event->direction == GDK_SCROLL_RIGHT);
2305 gboolean go_back = (event->direction == GDK_SCROLL_UP ||
2306 event->direction == GDK_SCROLL_LEFT);
2307
2308 if (!pane ||
2309 !gtk_widget_get_realized (w) ||
2310 event->direction == GDK_SCROLL_SMOOTH)
2311 return FALSE;
2312
2313 if ((event->state & GDK_SHIFT_MASK))
2314 go_horiz = !go_horiz;
2315
2316 if ((event->state & GDK_CONTROL_MASK)) { /* zoom */
2317 int zoom = (int)(sheet->last_zoom_factor_used * 100. + .5) - 10;
2318
2319 if ((zoom % 15) != 0) {
2320 zoom = 15 * (int)(zoom/15);
2321 if (go_back)
2322 zoom += 15;
2323 } else {
2324 if (go_back)
2325 zoom += 15;
2326 else
2327 zoom -= 15;
2328 }
2329
2330 if (0 <= zoom && zoom <= 390)
2331 cmd_zoom (GNM_WBC (wbcg), g_slist_append (NULL, sheet),
2332 (double) (zoom + 10) / 100);
2333 } else if (go_horiz) {
2334 int col = (pane->last_full.col - pane->first.col) / 4;
2335 if (col < 1)
2336 col = 1;
2337 if (go_back)
2338 col = pane->first.col - col;
2339 else
2340 col = pane->first.col + col;
2341 scg_set_left_col (pane->simple.scg, col);
2342 } else {
2343 int row = (pane->last_full.row - pane->first.row) / 4;
2344 if (row < 1)
2345 row = 1;
2346 if (go_back)
2347 row = pane->first.row - row;
2348 else
2349 row = pane->first.row + row;
2350 scg_set_top_row (pane->simple.scg, row);
2351 }
2352 return TRUE;
2353 }
2354
2355 /*
2356 * Make current control size the default. Toplevel would resize
2357 * spontaneously. This makes it stay the same size until user resizes.
2358 */
2359 static void
2360 cb_realize (GtkWindow *toplevel, WBCGtk *wbcg)
2361 {
2362 GtkAllocation ta;
2363
2364 g_return_if_fail (GTK_IS_WINDOW (toplevel));
2365
2366 gtk_widget_get_allocation (GTK_WIDGET (toplevel), &ta);
2367 gtk_window_set_default_size (toplevel, ta.width, ta.height);
2368
2369 /* if we are already initialized set the focus. Without this loading a
2370 * multpage book sometimes leaves focus on the last book rather than
2371 * the current book. Which leads to a slew of errors for keystrokes
2372 * until focus is corrected.
2373 */
2374 if (wbcg->snotebook) {
2375 wbcg_focus_cur_scg (wbcg);
2376 wbcg_update_menu_feedback (wbcg, wbcg_cur_sheet (wbcg));
2377 }
2378 }
2379
2380 static void
2381 cb_css_parse_error (GtkCssProvider *css, GtkCssSection *section, GError *err)
2382 {
2383 if (g_error_matches (err, GTK_CSS_PROVIDER_ERROR,
2384 GTK_CSS_PROVIDER_ERROR_DEPRECATED) &&
2385 !gnm_debug_flag ("css"))
2386 return;
2387
2388 g_warning ("Theme parsing error: %s", err->message);
2389 }
2390
2391 struct css_provider_data {
2392 GtkCssProvider *css;
2393 GSList *screens;
2394 };
2395
2396 static void
2397 cb_unload_providers (gpointer data_)
2398 {
2399 struct css_provider_data *data = data_;
2400 GSList *l;
2401
2402 for (l = data->screens; l; l = l->next) {
2403 GdkScreen *screen = l->data;
2404 gtk_style_context_remove_provider_for_screen
2405 (screen, GTK_STYLE_PROVIDER (data->css));
2406 }
2407 g_slist_free (data->screens);
2408 g_object_unref (data->css);
2409 g_free (data);
2410 }
2411
2412 static void
2413 cb_screen_changed (GtkWidget *widget)
2414 {
2415 GdkScreen *screen = gtk_widget_get_screen (widget);
2416 GObject *app = gnm_app_get_app ();
2417 const char *app_key = "css-provider";
2418 struct css_provider_data *data;
2419
2420 data = g_object_get_data (app, app_key);
2421 if (!data) {
2422 const char *resource = "/org/gnumeric/gnumeric/ui/gnumeric.css";
2423 GBytes *cssbytes = g_resources_lookup_data (resource, 0, NULL);
2424 const char *csstext = g_bytes_get_data (cssbytes, NULL);
2425 gboolean debug = gnm_debug_flag ("css");
2426
2427 data = g_new (struct css_provider_data, 1);
2428 data->css = gtk_css_provider_new ();
2429 data->screens = NULL;
2430
2431 if (debug)
2432 g_printerr ("Loading style from %s\n", resource);
2433 else
2434 g_signal_connect (data->css, "parsing-error",
2435 G_CALLBACK (cb_css_parse_error),
2436 NULL);
2437
2438 gtk_css_provider_load_from_data (data->css, csstext, -1, NULL);
2439 g_object_set_data_full (app, app_key, data, cb_unload_providers);
2440 g_bytes_unref (cssbytes);
2441 }
2442
2443 if (screen && !g_slist_find (data->screens, screen)) {
2444 gtk_style_context_add_provider_for_screen
2445 (screen,
2446 GTK_STYLE_PROVIDER (data->css),
2447 GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
2448 data->screens = g_slist_prepend (data->screens, screen);
2449 }
2450 }
2451
2452 void
2453 wbcg_set_status_text (WBCGtk *wbcg, char const *text)
2454 {
2455 g_return_if_fail (GNM_IS_WBC_GTK (wbcg));
2456 gtk_statusbar_pop (GTK_STATUSBAR (wbcg->status_text), 0);
2457 gtk_statusbar_push (GTK_STATUSBAR (wbcg->status_text), 0, text);
2458 }
2459
2460 static void
2461 set_visibility (WBCGtk *wbcg,
2462 char const *action_name,
2463 gboolean visible)
2464 {
2465 GtkWidget *w = g_hash_table_lookup (wbcg->visibility_widgets, action_name);
2466 if (w)
2467 gtk_widget_set_visible (w, visible);
2468 wbc_gtk_set_toggle_action_state (wbcg, action_name, visible);
2469 }
2470
2471
2472 void
2473 wbcg_toggle_visibility (WBCGtk *wbcg, GtkToggleAction *action)
2474 {
2475 if (!wbcg->updating_ui && wbcg_ui_update_begin (wbcg)) {
2476 char const *name = gtk_action_get_name (GTK_ACTION (action));
2477 set_visibility (wbcg, name,
2478 gtk_toggle_action_get_active (action));
2479 wbcg_ui_update_end (wbcg);
2480 }
2481 }
2482
2483 static void
2484 cb_visibility (char const *action, GtkWidget *orig_widget, WBCGtk *new_wbcg)
2485 {
2486 set_visibility (new_wbcg, action, gtk_widget_get_visible (orig_widget));
2487 }
2488
2489 void
2490 wbcg_copy_toolbar_visibility (WBCGtk *new_wbcg,
2491 WBCGtk *wbcg)
2492 {
2493 g_hash_table_foreach (wbcg->visibility_widgets,
2494 (GHFunc)cb_visibility, new_wbcg);
2495 }
2496
2497
2498 void
2499 wbcg_set_end_mode (WBCGtk *wbcg, gboolean flag)
2500 {
2501 g_return_if_fail (GNM_IS_WBC_GTK (wbcg));
2502
2503 if (!wbcg->last_key_was_end != !flag) {
2504 const char *txt = flag ? _("END") : "";
2505 wbcg_set_status_text (wbcg, txt);
2506 wbcg->last_key_was_end = flag;
2507 }
2508 }
2509
2510 static PangoFontDescription *
2511 settings_get_font_desc (GtkSettings *settings)
2512 {
2513 PangoFontDescription *font_desc;
2514 char *font_str;
2515
2516 g_object_get (settings, "gtk-font-name", &font_str, NULL);
2517 font_desc = pango_font_description_from_string (
2518 font_str ? font_str : "sans 10");
2519 g_free (font_str);
2520
2521 return font_desc;
2522 }
2523
2524 static void
2525 cb_update_item_bar_font (GtkWidget *w)
2526 {
2527 SheetControlGUI *scg = get_scg (w);
2528 sc_resize ((SheetControl *)scg, TRUE);
2529 }
2530
2531 static void
2532 cb_desktop_font_changed (GtkSettings *settings, GParamSpec *pspec,
2533 WBCGtk *wbcg)
2534 {
2535 if (wbcg->font_desc)
2536 pango_font_description_free (wbcg->font_desc);
2537 wbcg->font_desc = settings_get_font_desc (settings);
2538 gtk_container_foreach (GTK_CONTAINER (wbcg->snotebook),
2539 (GtkCallback)cb_update_item_bar_font, NULL);
2540 }
2541
2542 static GdkScreen *
2543 wbcg_get_screen (WBCGtk *wbcg)
2544 {
2545 return gtk_widget_get_screen (wbcg->notebook_area);
2546 }
2547
2548 static GtkSettings *
2549 wbcg_get_gtk_settings (WBCGtk *wbcg)
2550 {
2551 return gtk_settings_get_for_screen (wbcg_get_screen (wbcg));
2552 }
2553
2554 /* ------------------------------------------------------------------------- */
2555
2556 static int
2557 show_gui (WBCGtk *wbcg)
2558 {
2559 SheetControlGUI *scg;
2560 WorkbookView *wbv = wb_control_view (GNM_WBC (wbcg));
2561 int sx, sy;
2562 gdouble fx, fy;
2563 GdkRectangle rect;
2564 GdkScreen *screen = wbcg_get_screen (wbcg);
2565
2566 /* In a Xinerama setup, we want the geometry of the actual display
2567 * unit, if available. See bug 59902. */
2568 gdk_screen_get_monitor_geometry (screen, 0, &rect);
2569 sx = MAX (rect.width, 600);
2570 sy = MAX (rect.height, 200);
2571
2572 fx = gnm_conf_get_core_gui_window_x ();
2573 fy = gnm_conf_get_core_gui_window_y ();
2574
2575 /* Successfully parsed geometry string and urged WM to comply */
2576 if (NULL != wbcg->preferred_geometry && NULL != wbcg->toplevel &&
2577 gtk_window_parse_geometry (GTK_WINDOW (wbcg->toplevel),
2578 wbcg->preferred_geometry)) {
2579 g_free (wbcg->preferred_geometry);
2580 wbcg->preferred_geometry = NULL;
2581 } else if (wbcg->snotebook != NULL &&
2582 wbv != NULL &&
2583 (wbv->preferred_width > 0 || wbv->preferred_height > 0)) {
2584 /* Set grid size to preferred width */
2585 int pwidth = MIN(wbv->preferred_width, gdk_screen_get_width (screen));
2586 int pheight = MIN(wbv->preferred_height, gdk_screen_get_height (screen));
2587 GtkRequisition requisition;
2588
2589 pwidth = pwidth > 0 ? pwidth : -1;
2590 pheight = pheight > 0 ? pheight : -1;
2591 gtk_widget_set_size_request (GTK_WIDGET (wbcg->notebook_area),
2592 pwidth, pheight);
2593 gtk_widget_get_preferred_size (GTK_WIDGET (wbcg->toplevel),
2594 &requisition, NULL);
2595 /* We want to test if toplevel is bigger than screen.
2596 * gtk_widget_size_request tells us the space
2597 * allocated to the toplevel proper, but not how much is
2598 * need for WM decorations or a possible panel.
2599 *
2600 * The test below should very rarely maximize when there is
2601 * actually room on the screen.
2602 *
2603 * We maximize instead of resizing for two reasons:
2604 * - The preferred width / height is restored with one click on
2605 * unmaximize.
2606 * - We don't have to guess what size we should resize to.
2607 */
2608 if (requisition.height + 20 > rect.height ||
2609 requisition.width > rect.width) {
2610 gtk_window_maximize (GTK_WINDOW (wbcg->toplevel));
2611 } else {
2612 gtk_window_set_default_size
2613 (wbcg_toplevel (wbcg),
2614 requisition.width, requisition.height);
2615 }
2616 } else {
2617 /* Use default */
2618 gtk_window_set_default_size (wbcg_toplevel (wbcg), sx * fx, sy * fy);
2619 }
2620
2621 scg = wbcg_cur_scg (wbcg);
2622 if (scg)
2623 wbcg_set_direction (scg);
2624
2625 gtk_widget_show (GTK_WIDGET (wbcg_toplevel (wbcg)));
2626
2627 /* rehide headers if necessary */
2628 if (NULL != scg && wbcg_cur_sheet (wbcg))
2629 scg_adjust_preferences (scg);
2630
2631 gtk_widget_set_size_request (GTK_WIDGET (wbcg->notebook_area),
2632 -1, -1);
2633 return FALSE;
2634 }
2635
2636 static GtkWidget *
2637 wbcg_get_label_for_position (WBCGtk *wbcg, GtkWidget *source,
2638 gint x)
2639 {
2640 guint n, i;
2641 GtkWidget *last_visible = NULL;
2642
2643 g_return_val_if_fail (GNM_IS_WBC_GTK (wbcg), NULL);
2644
2645 n = wbcg_get_n_scg (wbcg);
2646 for (i = 0; i < n; i++) {
2647 GtkWidget *label = gnm_notebook_get_nth_label (wbcg->bnotebook, i);
2648 int x0, x1;
2649 GtkAllocation la;
2650
2651 if (!gtk_widget_get_visible (label))
2652 continue;
2653
2654 gtk_widget_get_allocation (label, &la);
2655 x0 = la.x;
2656 x1 = x0 + la.width;
2657
2658 if (x <= x1) {
2659 /*
2660 * We are left of this label's right edge. Use it
2661 * even if we are far left of the label.
2662 */
2663 return label;
2664 }
2665
2666 last_visible = label;
2667 }
2668
2669 return last_visible;
2670 }
2671
2672 static gboolean
2673 wbcg_is_local_drag (WBCGtk *wbcg, GtkWidget *source_widget)
2674 {
2675 GtkWidget *top = (GtkWidget *)wbcg_toplevel (wbcg);
2676 return GNM_IS_PANE (source_widget) &&
2677 gtk_widget_get_toplevel (source_widget) == top;
2678 }
2679 static gboolean
2680 cb_wbcg_drag_motion (GtkWidget *widget, GdkDragContext *context,
2681 gint x, gint y, guint time, WBCGtk *wbcg)
2682 {
2683 GtkWidget *source_widget = gtk_drag_get_source_widget (context);
2684
2685 if (GNM_IS_NOTEBOOK (gtk_widget_get_parent (source_widget))) {
2686 /* The user wants to reorder sheets. We simulate a
2687 * drag motion over a label.
2688 */
2689 GtkWidget *label = wbcg_get_label_for_position (wbcg, source_widget, x);
2690 return cb_sheet_label_drag_motion (label, context, x, y,
2691 time, wbcg);
2692 } else if (wbcg_is_local_drag (wbcg, source_widget))
2693 gnm_pane_object_autoscroll (GNM_PANE (source_widget),
2694 context, x, y, time);
2695
2696 return TRUE;
2697 }
2698
2699 static void
2700 cb_wbcg_drag_leave (GtkWidget *widget, GdkDragContext *context,
2701 guint time, WBCGtk *wbcg)
2702 {
2703 GtkWidget *source_widget = gtk_drag_get_source_widget (context);
2704
2705 g_return_if_fail (GNM_IS_WBC_GTK (wbcg));
2706
2707 if (GNM_IS_NOTEBOOK (gtk_widget_get_parent (source_widget)))
2708 gtk_widget_hide (
2709 g_object_get_data (G_OBJECT (source_widget), "arrow"));
2710 else if (wbcg_is_local_drag (wbcg, source_widget))
2711 gnm_pane_slide_stop (GNM_PANE (source_widget));
2712 }
2713
2714 static void
2715 cb_wbcg_drag_data_received (GtkWidget *widget, GdkDragContext *context,
2716 gint x, gint y, GtkSelectionData *selection_data,
2717 guint info, guint time, WBCGtk *wbcg)
2718 {
2719 gchar *target_type = gdk_atom_name (gtk_selection_data_get_target (selection_data));
2720
2721 if (!strcmp (target_type, "text/uri-list")) { /* filenames from nautilus */
2722 scg_drag_data_received (wbcg_cur_scg (wbcg),
2723 gtk_drag_get_source_widget (context), 0, 0,
2724 selection_data);
2725 } else if (!strcmp (target_type, "GNUMERIC_SHEET")) {
2726 /* The user wants to reorder the sheets but hasn't dropped
2727 * the sheet onto a label. Never mind. We figure out
2728 * where the arrow is currently located and simulate a drop
2729 * on that label. */
2730 GtkWidget *label = wbcg_get_label_for_position (wbcg,
2731 gtk_drag_get_source_widget (context), x);
2732 cb_sheet_label_drag_data_received (label, context, x, y,
2733 selection_data, info, time, wbcg);
2734 } else {
2735 GtkWidget *source_widget = gtk_drag_get_source_widget (context);
2736 if (wbcg_is_local_drag (wbcg, source_widget))
2737 g_printerr ("autoscroll complete - stop it\n");
2738 else
2739 scg_drag_data_received (wbcg_cur_scg (wbcg),
2740 source_widget, 0, 0, selection_data);
2741 }
2742 g_free (target_type);
2743 }
2744
2745 static void cb_cs_go_up (WBCGtk *wbcg)
2746 { wb_control_navigate_to_cell (GNM_WBC (wbcg), navigator_top); }
2747 static void cb_cs_go_down (WBCGtk *wbcg)
2748 { wb_control_navigate_to_cell (GNM_WBC (wbcg), navigator_bottom); }
2749 static void cb_cs_go_left (WBCGtk *wbcg)
2750 { wb_control_navigate_to_cell (GNM_WBC (wbcg), navigator_first); }
2751 static void cb_cs_go_right (WBCGtk *wbcg)
2752 { wb_control_navigate_to_cell (GNM_WBC (wbcg), navigator_last); }
2753 static void cb_cs_go_to_cell (WBCGtk *wbcg) { dialog_goto_cell (wbcg); }
2754
2755 static void
2756 wbc_gtk_cell_selector_popup (G_GNUC_UNUSED GtkEntry *entry,
2757 G_GNUC_UNUSED GtkEntryIconPosition icon_pos,
2758 G_GNUC_UNUSED GdkEvent *event,
2759 gpointer data)
2760 {
2761 if (event->type == GDK_BUTTON_PRESS) {
2762 WBCGtk *wbcg = data;
2763
2764 struct CellSelectorMenu {
2765 gchar const *text;
2766 void (*function) (WBCGtk *wbcg);
2767 } const cell_selector_actions [] = {
2768 { N_("Go to Top"), &cb_cs_go_up },
2769 { N_("Go to Bottom"), &cb_cs_go_down },
2770 { N_("Go to First"), &cb_cs_go_left },
2771 { N_("Go to Last"), &cb_cs_go_right },
2772 { NULL, NULL },
2773 { N_("Go to Cell..."), &cb_cs_go_to_cell }
2774 };
2775 unsigned int ui;
2776 GtkWidget *item, *menu = gtk_menu_new ();
2777 gboolean active = (!wbcg_is_editing (wbcg) &&
2778 NULL == wbc_gtk_get_guru (wbcg));
2779
2780 for (ui = 0; ui < G_N_ELEMENTS (cell_selector_actions); ui++) {
2781 const struct CellSelectorMenu *it =
2782 cell_selector_actions + ui;
2783 if (it->text)
2784 item = gtk_image_menu_item_new_with_label
2785 (_(it->text));
2786 else
2787 item = gtk_separator_menu_item_new ();
2788
2789 if (it->function)
2790 g_signal_connect_swapped
2791 (G_OBJECT (item), "activate",
2792 G_CALLBACK (it->function), wbcg);
2793 gtk_widget_set_sensitive (item, active);
2794 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
2795 gtk_widget_show (item);
2796 }
2797
2798 gnumeric_popup_menu (GTK_MENU (menu), event);
2799 }
2800 }
2801
2802 static void
2803 wbc_gtk_create_edit_area (WBCGtk *wbcg)
2804 {
2805 GtkToolItem *item;
2806 GtkEntry *entry;
2807 int len;
2808 GtkWidget *debug_button;
2809
2810 wbc_gtk_init_editline (wbcg);
2811 entry = wbcg_get_entry (wbcg);
2812
2813 /* Set a reasonable width for the selection box. */
2814 len = gnm_widget_measure_string
2815 (GTK_WIDGET (wbcg_toplevel (wbcg)),
2816 cell_coord_name (GNM_MAX_COLS - 1, GNM_MAX_ROWS - 1));
2817 /*
2818 * Add a little extra since font might be proportional and since
2819 * we also put user defined names there.
2820 */
2821 len = len * 3 / 2;
2822 gtk_widget_set_size_request (wbcg->selection_descriptor, len, -1);
2823
2824 g_signal_connect_swapped (wbcg->cancel_button,
2825 "clicked", G_CALLBACK (cb_cancel_input),
2826 wbcg);
2827
2828 g_signal_connect_swapped (wbcg->ok_button,
2829 "clicked", G_CALLBACK (cb_accept_input),
2830 wbcg);
2831 gtk_menu_tool_button_set_menu (GTK_MENU_TOOL_BUTTON (wbcg->ok_button),
2832 gtk_menu_new ());
2833 gtk_menu_tool_button_set_arrow_tooltip_text
2834 (GTK_MENU_TOOL_BUTTON (wbcg->ok_button),
2835 _("Accept change in multiple cells"));
2836 g_signal_connect (wbcg->ok_button,
2837 "show-menu", G_CALLBACK (cb_accept_input_menu),
2838 wbcg);
2839
2840 g_signal_connect_swapped (wbcg->func_button,
2841 "clicked", G_CALLBACK (cb_autofunction),
2842 wbcg);
2843
2844 /* Dependency debugger */
2845 debug_button = GET_GUI_ITEM ("debug_button");
2846 if (gnm_debug_flag ("notebook-size") ||
2847 gnm_debug_flag ("deps") ||
2848 gnm_debug_flag ("expr-sharer") ||
2849 gnm_debug_flag ("style-optimize") ||
2850 gnm_debug_flag ("name-collections")) {
2851 g_signal_connect_swapped (debug_button,
2852 "clicked", G_CALLBACK (cb_workbook_debug_info),
2853 wbcg);
2854 } else {
2855 gtk_widget_destroy (debug_button);
2856 }
2857
2858 item = GET_GUI_ITEM ("edit_line_entry_item");
2859 gtk_container_add (GTK_CONTAINER (item),
2860 GTK_WIDGET (wbcg->edit_line.entry));
2861 gtk_widget_show_all (GTK_WIDGET (item));
2862
2863 /* Do signal setup for the editing input line */
2864 g_signal_connect (G_OBJECT (entry),
2865 "focus-in-event",
2866 G_CALLBACK (cb_editline_focus_in), wbcg);
2867
2868 /* status box */
2869 g_signal_connect (G_OBJECT (wbcg->selection_descriptor),
2870 "activate",
2871 G_CALLBACK (cb_statusbox_activate), wbcg);
2872 g_signal_connect (G_OBJECT (wbcg->selection_descriptor),
2873 "focus-out-event",
2874 G_CALLBACK (cb_statusbox_focus), wbcg);
2875
2876 gtk_entry_set_icon_from_icon_name
2877 (GTK_ENTRY (wbcg->selection_descriptor),
2878 GTK_ENTRY_ICON_SECONDARY, "go-jump");
2879 gtk_entry_set_icon_sensitive
2880 (GTK_ENTRY (wbcg->selection_descriptor),
2881 GTK_ENTRY_ICON_SECONDARY, TRUE);
2882 gtk_entry_set_icon_activatable
2883 (GTK_ENTRY (wbcg->selection_descriptor),
2884 GTK_ENTRY_ICON_SECONDARY, TRUE);
2885
2886 g_signal_connect (G_OBJECT (wbcg->selection_descriptor),
2887 "icon-press",
2888 G_CALLBACK
2889 (wbc_gtk_cell_selector_popup),
2890 wbcg);
2891 }
2892
2893 static int
2894 wbcg_validation_msg (WorkbookControl *wbc, ValidationStyle v,
2895 char const *title, char const *msg)
2896 {
2897 WBCGtk *wbcg = (WBCGtk *)wbc;
2898 ValidationStatus res0, res1 = GNM_VALIDATION_STATUS_VALID; /* supress warning */
2899 char const *btn0, *btn1;
2900 GtkMessageType type;
2901 GtkWidget *dialog;
2902 int response;
2903
2904 switch (v) {
2905 case GNM_VALIDATION_STYLE_STOP:
2906 res0 = GNM_VALIDATION_STATUS_INVALID_EDIT;
2907 btn0 = _("_Re-Edit");
2908 res1 = GNM_VALIDATION_STATUS_INVALID_DISCARD;
2909 btn1 = _("_Discard");
2910 type = GTK_MESSAGE_ERROR;
2911 break;
2912 case GNM_VALIDATION_STYLE_WARNING:
2913 res0 = GNM_VALIDATION_STATUS_VALID;
2914 btn0 = _("_Accept");
2915 res1 = GNM_VALIDATION_STATUS_INVALID_DISCARD;
2916 btn1 = _("_Discard");
2917 type = GTK_MESSAGE_WARNING;
2918 break;
2919 case GNM_VALIDATION_STYLE_INFO:
2920 res0 = GNM_VALIDATION_STATUS_VALID;
2921 btn0 = GNM_STOCK_OK;
2922 btn1 = NULL;
2923 type = GTK_MESSAGE_INFO;
2924 break;
2925 case GNM_VALIDATION_STYLE_PARSE_ERROR:
2926 res0 = GNM_VALIDATION_STATUS_INVALID_EDIT;
2927 btn0 = _("_Re-Edit");
2928 res1 = GNM_VALIDATION_STATUS_VALID;
2929 btn1 = _("_Accept");
2930 type = GTK_MESSAGE_ERROR;
2931 break;
2932
2933 default:
2934 g_assert_not_reached ();
2935 }
2936
2937 dialog = gtk_message_dialog_new (wbcg_toplevel (wbcg),
2938 GTK_DIALOG_DESTROY_WITH_PARENT,
2939 type, GTK_BUTTONS_NONE, "%s", msg);
2940 gtk_dialog_add_buttons (GTK_DIALOG (dialog),
2941 btn0, GTK_RESPONSE_YES,
2942 btn1, GTK_RESPONSE_NO,
2943 NULL);
2944 /* TODO : what to use if nothing is specified ? */
2945 /* TODO : do we want the document name here too ? */
2946 if (title)
2947 gtk_window_set_title (GTK_WINDOW (dialog), title);
2948 gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_NO);
2949 response = go_gtk_dialog_run (GTK_DIALOG (dialog),
2950 wbcg_toplevel (wbcg));
2951 return ((response == GTK_RESPONSE_NO || response == GTK_RESPONSE_CANCEL) ? res1 : res0);
2952 }
2953
2954 #define DISCONNECT(obj,field) \
2955 if (wbcg->field) { \
2956 if (obj) \
2957 g_signal_handler_disconnect (obj, wbcg->field); \
2958 wbcg->field = 0; \
2959 }
2960
2961 static void
2962 wbcg_view_changed (WBCGtk *wbcg,
2963 G_GNUC_UNUSED GParamSpec *pspec,
2964 Workbook *old_wb)
2965 {
2966 WorkbookControl *wbc = GNM_WBC (wbcg);
2967 Workbook *wb = wb_control_get_workbook (wbc);
2968 WorkbookView *wbv = wb_control_view (wbc);
2969
2970 /* Reconnect self because we need to change data. */
2971 DISCONNECT (wbc, sig_view_changed);
2972 wbcg->sig_view_changed =
2973 g_signal_connect_object
2974 (G_OBJECT (wbc),
2975 "notify::view",
2976 G_CALLBACK (wbcg_view_changed),
2977 wb,
2978 0);
2979
2980 DISCONNECT (wbcg->sig_wbv, sig_auto_expr_text);
2981 DISCONNECT (wbcg->sig_wbv, sig_auto_expr_attrs);
2982 DISCONNECT (wbcg->sig_wbv, sig_show_horizontal_scrollbar);
2983 DISCONNECT (wbcg->sig_wbv, sig_show_vertical_scrollbar);
2984 DISCONNECT (wbcg->sig_wbv, sig_show_notebook_tabs);
2985 if (wbcg->sig_wbv)
2986 g_object_remove_weak_pointer (wbcg->sig_wbv,
2987 &wbcg->sig_wbv);
2988 wbcg->sig_wbv = wbv;
2989 if (wbv) {
2990 g_object_add_weak_pointer (wbcg->sig_wbv,
2991 &wbcg->sig_wbv);
2992 wbcg->sig_auto_expr_text =
2993 g_signal_connect_object
2994 (G_OBJECT (wbv),
2995 "notify::auto-expr-value",
2996 G_CALLBACK (wbcg_auto_expr_value_changed),
2997 wbcg,
2998 0);
2999 wbcg_auto_expr_value_changed (wbv, NULL, wbcg);
3000
3001 wbcg->sig_show_horizontal_scrollbar =
3002 g_signal_connect_object
3003 (G_OBJECT (wbv),
3004 "notify::show-horizontal-scrollbar",
3005 G_CALLBACK (wbcg_scrollbar_visibility),
3006 wbcg,
3007 0);
3008 wbcg->sig_show_vertical_scrollbar =
3009 g_signal_connect_object
3010 (G_OBJECT (wbv),
3011 "notify::show-vertical-scrollbar",
3012 G_CALLBACK (wbcg_scrollbar_visibility),
3013 wbcg,
3014 0);
3015 wbcg->sig_show_notebook_tabs =
3016 g_signal_connect_object
3017 (G_OBJECT (wbv),
3018 "notify::show-notebook-tabs",
3019 G_CALLBACK (wbcg_notebook_tabs_visibility),
3020 wbcg,
3021 0);
3022 wbcg_notebook_tabs_visibility (wbv, NULL, wbcg);
3023 }
3024
3025 DISCONNECT (old_wb, sig_sheet_order);
3026 DISCONNECT (old_wb, sig_notify_uri);
3027 DISCONNECT (old_wb, sig_notify_dirty);
3028
3029 if (wb) {
3030 wbcg->sig_sheet_order =
3031 g_signal_connect_object
3032 (G_OBJECT (wb),
3033 "sheet-order-changed",
3034 G_CALLBACK (wbcg_sheet_order_changed),
3035 wbcg, G_CONNECT_SWAPPED);
3036
3037 wbcg->sig_notify_uri =
3038 g_signal_connect_object
3039 (G_OBJECT (wb),
3040 "notify::uri",
3041 G_CALLBACK (wbcg_update_title),
3042 wbcg, G_CONNECT_SWAPPED);
3043
3044 wbcg->sig_notify_dirty =
3045 g_signal_connect_object
3046 (G_OBJECT (wb),
3047 "notify::dirty",
3048 G_CALLBACK (wbcg_update_title),
3049 wbcg, G_CONNECT_SWAPPED);
3050
3051 wbcg_update_title (wbcg);
3052 }
3053 }
3054
3055 #undef DISCONNECT
3056
3057 /***************************************************************************/
3058
3059 static GOActionComboStack *
3060 ur_stack (WorkbookControl *wbc, gboolean is_undo)
3061 {
3062 WBCGtk *wbcg = (WBCGtk *)wbc;
3063 return is_undo ? wbcg->undo_haction : wbcg->redo_haction;
3064 }
3065
3066 static void
3067 wbc_gtk_undo_redo_truncate (WorkbookControl *wbc, int n, gboolean is_undo)
3068 {
3069 go_action_combo_stack_truncate (ur_stack (wbc, is_undo), n);
3070 }
3071
3072 static void
3073 wbc_gtk_undo_redo_pop (WorkbookControl *wbc, gboolean is_undo)
3074 {
3075 go_action_combo_stack_pop (ur_stack (wbc, is_undo), 1);
3076 }
3077
3078 static void
3079 wbc_gtk_undo_redo_push (WorkbookControl *wbc, gboolean is_undo,
3080 char const *text, gpointer key)
3081 {
3082 go_action_combo_stack_push (ur_stack (wbc, is_undo), text, key);
3083 }
3084
3085 /****************************************************************************/
3086
3087 static void
3088 set_font_name_feedback (GtkAction *act, const char *family)
3089 {
3090 PangoFontDescription *desc = pango_font_description_new ();
3091 pango_font_description_set_family (desc, family);
3092 wbcg_font_action_set_font_desc (act, desc);
3093 pango_font_description_free (desc);
3094 }
3095
3096 static void
3097 set_font_size_feedback (GtkAction *act, double size)
3098 {
3099 PangoFontDescription *desc = pango_font_description_new ();
3100 pango_font_description_set_size (desc, size * PANGO_SCALE);
3101 wbcg_font_action_set_font_desc (act, desc);
3102 pango_font_description_free (desc);
3103 }
3104
3105 /****************************************************************************/
3106
3107 static WorkbookControl *
3108 wbc_gtk_control_new (G_GNUC_UNUSED WorkbookControl *wbc,
3109 WorkbookView *wbv,
3110 Workbook *wb,
3111 gpointer extra)
3112 {
3113 return (WorkbookControl *)wbc_gtk_new (wbv, wb,
3114 extra ? GDK_SCREEN (extra) : NULL, NULL);
3115 }
3116
3117 static void
3118 wbc_gtk_init_state (WorkbookControl *wbc)
3119 {
3120 WorkbookView *wbv = wb_control_view (wbc);
3121 WBCGtk *wbcg = WBC_GTK (wbc);
3122
3123 /* Share a colour history for all a view's controls */
3124 go_action_combo_color_set_group (wbcg->back_color, wbv);
3125 go_action_combo_color_set_group (wbcg->fore_color, wbv);
3126 }
3127
3128 static void
3129 wbc_gtk_style_feedback_real (WorkbookControl *wbc, GnmStyle const *changes)
3130 {
3131 WorkbookView *wb_view = wb_control_view (wbc);
3132 WBCGtk *wbcg = (WBCGtk *)wbc;
3133
3134 g_return_if_fail (wb_view != NULL);
3135
3136 if (!wbcg_ui_update_begin (WBC_GTK (wbc)))
3137 return;
3138
3139 if (changes == NULL)
3140 changes = wb_view->current_style;
3141
3142 if (gnm_style_is_element_set (changes, MSTYLE_FONT_BOLD))
3143 gtk_toggle_action_set_active (wbcg->font.bold,
3144 gnm_style_get_font_bold (changes));
3145 if (gnm_style_is_element_set (changes, MSTYLE_FONT_ITALIC))
3146 gtk_toggle_action_set_active (wbcg->font.italic,
3147 gnm_style_get_font_italic (changes));
3148 if (gnm_style_is_element_set (changes, MSTYLE_FONT_UNDERLINE)) {
3149 gtk_toggle_action_set_active (wbcg->font.underline,
3150 gnm_style_get_font_uline (changes) == UNDERLINE_SINGLE);
3151 gtk_toggle_action_set_active (wbcg->font.d_underline,
3152 gnm_style_get_font_uline (changes) == UNDERLINE_DOUBLE);
3153 gtk_toggle_action_set_active (wbcg->font.sl_underline,
3154 gnm_style_get_font_uline (changes) == UNDERLINE_SINGLE_LOW);
3155 gtk_toggle_action_set_active (wbcg->font.dl_underline,
3156 gnm_style_get_font_uline (changes) == UNDERLINE_DOUBLE_LOW);
3157 }
3158 if (gnm_style_is_element_set (changes, MSTYLE_FONT_STRIKETHROUGH))
3159 gtk_toggle_action_set_active (wbcg->font.strikethrough,
3160 gnm_style_get_font_strike (changes));
3161
3162 if (gnm_style_is_element_set (changes, MSTYLE_FONT_SCRIPT)) {
3163 gtk_toggle_action_set_active (wbcg->font.superscript,
3164 gnm_style_get_font_script (changes) == GO_FONT_SCRIPT_SUPER);
3165 gtk_toggle_action_set_active (wbcg->font.subscript,
3166 gnm_style_get_font_script (changes) == GO_FONT_SCRIPT_SUB);
3167 } else {
3168 gtk_toggle_action_set_active (wbcg->font.superscript, FALSE);
3169 gtk_toggle_action_set_active (wbcg->font.subscript, FALSE);
3170 }
3171
3172 if (gnm_style_is_element_set (changes, MSTYLE_ALIGN_H)) {
3173 GnmHAlign align = gnm_style_get_align_h (changes);
3174 gtk_toggle_action_set_active (wbcg->h_align.left,
3175 align == GNM_HALIGN_LEFT);
3176 gtk_toggle_action_set_active (wbcg->h_align.center,
3177 align == GNM_HALIGN_CENTER);
3178 gtk_toggle_action_set_active (wbcg->h_align.right,
3179 align == GNM_HALIGN_RIGHT);
3180 gtk_toggle_action_set_active (wbcg->h_align.center_across_selection,
3181 align == GNM_HALIGN_CENTER_ACROSS_SELECTION);
3182 go_action_combo_pixmaps_select_id (wbcg->halignment, align);
3183 }
3184 if (gnm_style_is_element_set (changes, MSTYLE_ALIGN_V)) {
3185 GnmVAlign align = gnm_style_get_align_v (changes);
3186 gtk_toggle_action_set_active (wbcg->v_align.top,
3187 align == GNM_VALIGN_TOP);
3188 gtk_toggle_action_set_active (wbcg->v_align.bottom,
3189 align == GNM_VALIGN_BOTTOM);
3190 gtk_toggle_action_set_active (wbcg->v_align.center,
3191 align == GNM_VALIGN_CENTER);
3192 go_action_combo_pixmaps_select_id (wbcg->valignment, align);
3193 }
3194
3195 if (gnm_style_is_element_set (changes, MSTYLE_FONT_SIZE)) {
3196 set_font_size_feedback (wbcg->font_name_haction,
3197 gnm_style_get_font_size (changes));
3198 set_font_size_feedback (wbcg->font_name_vaction,
3199 gnm_style_get_font_size (changes));
3200 }
3201
3202 if (gnm_style_is_element_set (changes, MSTYLE_FONT_NAME)) {
3203 set_font_name_feedback (wbcg->font_name_haction,
3204 gnm_style_get_font_name (changes));
3205 set_font_name_feedback (wbcg->font_name_vaction,
3206 gnm_style_get_font_name (changes));
3207 }
3208
3209 wbcg_ui_update_end (WBC_GTK (wbc));
3210 }
3211
3212 static gint
3213 cb_wbc_gtk_style_feedback (WBCGtk *gtk)
3214 {
3215 wbc_gtk_style_feedback_real ((WorkbookControl *)gtk, NULL);
3216 gtk->idle_update_style_feedback = 0;
3217 return FALSE;
3218 }
3219 static void
3220 wbc_gtk_style_feedback (WorkbookControl *wbc, GnmStyle const *changes)
3221 {
3222 WBCGtk *wbcg = (WBCGtk *)wbc;
3223
3224 if (changes)
3225 wbc_gtk_style_feedback_real (wbc, changes);
3226 else if (0 == wbcg->idle_update_style_feedback)
3227 wbcg->idle_update_style_feedback = g_timeout_add (200,
3228 (GSourceFunc) cb_wbc_gtk_style_feedback, wbc);
3229 }
3230
3231 static void
3232 cb_handlebox_dock_status (GtkHandleBox *hb,
3233 GtkToolbar *toolbar, gpointer pattached)
3234 {
3235 gboolean attached = GPOINTER_TO_INT (pattached);
3236 gtk_toolbar_set_show_arrow (toolbar, attached);
3237 }
3238
3239 static char const *
3240 get_accel_label (GtkMenuItem *item, guint *key)
3241 {
3242 GList *children = gtk_container_get_children (GTK_CONTAINER (item));
3243 GList *l;
3244 char const *res = NULL;
3245
3246 *key = GDK_KEY_VoidSymbol;
3247 for (l = children; l; l = l->next) {
3248 GtkWidget *w = l->data;
3249
3250 if (GTK_IS_ACCEL_LABEL (w)) {
3251 *key = gtk_label_get_mnemonic_keyval (GTK_LABEL (w));
3252 res = gtk_label_get_label (GTK_LABEL (w));
3253 break;
3254 }
3255 }
3256
3257 g_list_free (children);
3258 return res;
3259 }
3260
3261 static void
3262 check_underlines (GtkWidget *w, char const *path)
3263 {
3264 GList *children = gtk_container_get_children (GTK_CONTAINER (w));
3265 GHashTable *used = g_hash_table_new_full (NULL, NULL, NULL, (GDestroyNotify)g_free);
3266 GList *l;
3267
3268 for (l = children; l; l = l->next) {
3269 GtkMenuItem *item = GTK_MENU_ITEM (l->data);
3270 GtkWidget *sub = gtk_menu_item_get_submenu (item);
3271 guint key;
3272 char const *label = get_accel_label (item, &key);
3273
3274 if (sub) {
3275 char *newpath = g_strconcat (path, *path ? "->" : "", label, NULL);
3276 check_underlines (sub, newpath);
3277 g_free (newpath);
3278 }
3279
3280 if (key != GDK_KEY_VoidSymbol) {
3281 char const *prev = g_hash_table_lookup (used, GUINT_TO_POINTER (key));
3282 if (prev) {
3283 /* xgettext: Translators: if this warning shows up when
3284 * running Gnumeric in your locale, the underlines need
3285 * to be moved in strings representing menu entries.
3286 * One slightly tricky point here is that in certain cases,
3287 * the same menu entry shows up in more than one menu.
3288 */
3289 g_warning (_("In the `%s' menu, the key `%s' is used for both `%s' and `%s'."),
3290 path, gdk_keyval_name (key), prev, label);
3291 } else
3292 g_hash_table_insert (used, GUINT_TO_POINTER (key), g_strdup (label));
3293 }
3294 }
3295
3296 g_list_free (children);
3297 g_hash_table_destroy (used);
3298 }
3299
3300 /****************************************************************************/
3301 /* window list menu */
3302
3303 static void
3304 cb_window_menu_activate (GObject *action, WBCGtk *wbcg)
3305 {
3306 gtk_window_present (wbcg_toplevel (wbcg));
3307 }
3308
3309 static unsigned
3310 regenerate_window_menu (WBCGtk *gtk, Workbook *wb, unsigned i)
3311 {
3312 int k, count;
3313 char *basename = GO_DOC (wb)->uri
3314 ? go_basename_from_uri (GO_DOC (wb)->uri)
3315 : NULL;
3316
3317 /* How many controls are there? */
3318 count = 0;
3319 WORKBOOK_FOREACH_CONTROL (wb, wbv, wbc, {
3320 if (GNM_IS_WBC_GTK (wbc))
3321 count++;
3322 });
3323
3324 k = 1;
3325 WORKBOOK_FOREACH_CONTROL (wb, wbv, wbc, {
3326 if (i >= 20)
3327 return i;
3328 if (GNM_IS_WBC_GTK (wbc) && basename) {
3329 GString *label = g_string_new (NULL);
3330 char *name;
3331 char const *s;
3332 GtkActionEntry entry;
3333
3334 if (i < 10) g_string_append_c (label, '_');
3335 g_string_append_printf (label, "%d ", i);
3336
3337 for (s = basename; *s; s++) {
3338 if (*s == '_')
3339 g_string_append_c (label, '_');
3340 g_string_append_c (label, *s);
3341 }
3342
3343 if (count > 1)
3344 g_string_append_printf (label, " #%d", k++);
3345
3346 entry.name = name = g_strdup_printf ("WindowListEntry%d", i);
3347 entry.stock_id = NULL;
3348 entry.label = label->str;
3349 entry.accelerator = NULL;
3350 entry.tooltip = NULL;
3351 entry.callback = G_CALLBACK (cb_window_menu_activate);
3352
3353 gtk_action_group_add_actions (gtk->windows.actions,
3354 &entry, 1, wbc);
3355
3356 g_string_free (label, TRUE);
3357 g_free (name);
3358 i++;
3359 }});
3360 g_free (basename);
3361 return i;
3362 }
3363
3364 static void
3365 cb_regenerate_window_menu (WBCGtk *gtk)
3366 {
3367 Workbook *wb = wb_control_get_workbook (GNM_WBC (gtk));
3368 GList const *ptr;
3369 unsigned i;
3370
3371 /* This can happen during exit. */
3372 if (!wb)
3373 return;
3374
3375 if (gtk->windows.merge_id != 0)
3376 gtk_ui_manager_remove_ui (gtk->ui, gtk->windows.merge_id);
3377 gtk->windows.merge_id = gtk_ui_manager_new_merge_id (gtk->ui);
3378
3379 if (gtk->windows.actions != NULL) {
3380 gtk_ui_manager_remove_action_group (gtk->ui,
3381 gtk->windows.actions);
3382 g_object_unref (gtk->windows.actions);
3383 }
3384 gtk->windows.actions = gtk_action_group_new ("WindowList");
3385
3386 gtk_ui_manager_insert_action_group (gtk->ui, gtk->windows.actions, 0);
3387
3388 /* create the actions */
3389 i = regenerate_window_menu (gtk, wb, 1); /* current wb first */
3390 for (ptr = gnm_app_workbook_list (); ptr != NULL ; ptr = ptr->next)
3391 if (ptr->data != wb)
3392 i = regenerate_window_menu (gtk, ptr->data, i);
3393
3394 /* merge them in */
3395 while (i-- > 1) {
3396 char *name = g_strdup_printf ("WindowListEntry%d", i);
3397 gtk_ui_manager_add_ui (gtk->ui, gtk->windows.merge_id,
3398 "/menubar/View/Windows", name, name,
3399 GTK_UI_MANAGER_AUTO, TRUE);
3400 g_free (name);
3401 }
3402 }
3403
3404 typedef struct {
3405 GtkActionGroup *actions;
3406 guint merge_id;
3407 } CustomUIHandle;
3408
3409 static void
3410 cb_custom_ui_handler (GObject *gtk_action, WorkbookControl *wbc)
3411 {
3412 GnmAction *action = g_object_get_data (gtk_action, "GnmAction");
3413 GnmAppExtraUI *extra_ui = g_object_get_data (gtk_action, "ExtraUI");
3414
3415 g_return_if_fail (action != NULL);
3416 g_return_if_fail (action->handler != NULL);
3417 g_return_if_fail (extra_ui != NULL);
3418
3419 action->handler (action, wbc, extra_ui->user_data);
3420 }
3421
3422 static void
3423 cb_add_custom_ui (G_GNUC_UNUSED GnmApp *app,
3424 GnmAppExtraUI *extra_ui, WBCGtk *gtk)
3425 {
3426 CustomUIHandle *details;
3427 GSList *ptr;
3428 GError *error = NULL;
3429 const char *ui_substr;
3430
3431 details = g_new0 (CustomUIHandle, 1);
3432 details->actions = gtk_action_group_new (extra_ui->group_name);
3433
3434 for (ptr = extra_ui->actions; ptr != NULL ; ptr = ptr->next) {
3435 GnmAction *action = ptr->data;
3436 GtkAction *res;
3437 GtkActionEntry entry;
3438
3439 entry.name = action->id;
3440 entry.stock_id = action->icon_name;
3441 entry.label = action->label;
3442 entry.accelerator = NULL;
3443 entry.tooltip = NULL;
3444 entry.callback = G_CALLBACK (cb_custom_ui_handler);
3445 gtk_action_group_add_actions (details->actions, &entry, 1, gtk);
3446 res = gtk_action_group_get_action (details->actions, action->id);
3447 g_object_set_data (G_OBJECT (res), "GnmAction", action);
3448 g_object_set_data (G_OBJECT (res), "ExtraUI", extra_ui);
3449 }
3450 gtk_ui_manager_insert_action_group (gtk->ui, details->actions, 0);
3451
3452 ui_substr = strstr (extra_ui->layout, "<ui>");
3453 if (ui_substr == extra_ui->layout)
3454 ui_substr = NULL;
3455
3456 details->merge_id = gtk_ui_manager_add_ui_from_string
3457 (gtk->ui, extra_ui->layout, -1, ui_substr ? NULL : &error);
3458 if (details->merge_id == 0 && ui_substr) {
3459 /* Work around bug 569724. */
3460 details->merge_id = gtk_ui_manager_add_ui_from_string
3461 (gtk->ui, ui_substr, -1, &error);
3462 }
3463
3464 if (error) {
3465 g_message ("building menus failed: %s", error->message);
3466 g_error_free (error);
3467 gtk_ui_manager_remove_action_group (gtk->ui, details->actions);
3468 g_object_unref (details->actions);
3469 g_free (details);
3470 } else {
3471 g_hash_table_insert (gtk->custom_uis, extra_ui, details);
3472 }
3473 }
3474 static void
3475 cb_remove_custom_ui (G_GNUC_UNUSED GnmApp *app,
3476 GnmAppExtraUI *extra_ui, WBCGtk *gtk)
3477 {
3478 CustomUIHandle *details = g_hash_table_lookup (gtk->custom_uis, extra_ui);
3479 if (NULL != details) {
3480 gtk_ui_manager_remove_ui (gtk->ui, details->merge_id);
3481 gtk_ui_manager_remove_action_group (gtk->ui, details->actions);
3482 g_object_unref (details->actions);
3483 g_hash_table_remove (gtk->custom_uis, extra_ui);
3484 }
3485 }
3486
3487 static void
3488 cb_init_extra_ui (GnmAppExtraUI *extra_ui, WBCGtk *gtk)
3489 {
3490 cb_add_custom_ui (NULL, extra_ui, gtk);
3491 }
3492
3493 /****************************************************************************/
3494 /* Toolbar menu */
3495
3496 static void
3497 set_toolbar_style_for_position (GtkToolbar *tb, GtkPositionType pos)
3498 {
3499 GtkWidget *box = gtk_widget_get_parent (GTK_WIDGET (tb));
3500
3501 static const GtkOrientation orientations[] = {
3502 GTK_ORIENTATION_VERTICAL, GTK_ORIENTATION_VERTICAL,
3503 GTK_ORIENTATION_HORIZONTAL, GTK_ORIENTATION_HORIZONTAL
3504 };
3505
3506 gtk_orientable_set_orientation (GTK_ORIENTABLE (tb),
3507 orientations[pos]);
3508
3509 if (GTK_IS_HANDLE_BOX (box)) {
3510 static const GtkPositionType hdlpos[] = {
3511 GTK_POS_TOP, GTK_POS_TOP,
3512 GTK_POS_LEFT, GTK_POS_LEFT
3513 };
3514
3515 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (box),
3516 hdlpos[pos]);
3517 }
3518 if (pos == GTK_POS_TOP || pos == GTK_POS_BOTTOM)
3519 g_object_set (G_OBJECT (tb), "hexpand", TRUE, "vexpand", FALSE, NULL);
3520 else
3521 g_object_set (G_OBJECT (tb), "vexpand", TRUE, "hexpand", FALSE, NULL);
3522 }
3523
3524 static void
3525 set_toolbar_position (GtkToolbar *tb, GtkPositionType pos, WBCGtk *gtk)
3526 {
3527 GtkWidget *box = gtk_widget_get_parent (GTK_WIDGET (tb));
3528 GtkContainer *zone = GTK_CONTAINER (gtk_widget_get_parent (GTK_WIDGET (box)));
3529 GtkContainer *new_zone = GTK_CONTAINER (gtk->toolbar_zones[pos]);
3530 char const *name = g_object_get_data (G_OBJECT (box), "name");
3531 const char *key = "toolbar-order";
3532 int n = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (box), key));
3533 GList *children, *l;
3534 int cpos = 0;
3535
3536 if (zone == new_zone)
3537 return;
3538
3539 g_object_ref (box);
3540 if (zone)
3541 gtk_container_remove (zone, box);
3542 set_toolbar_style_for_position (tb, pos);
3543
3544 children = gtk_container_get_children (new_zone);
3545 for (l = children; l; l = l->next) {
3546 GObject *child = l->data;
3547 int nc = GPOINTER_TO_INT (g_object_get_data (child, key));
3548 if (nc < n) cpos++;
3549 }
3550 g_list_free (children);
3551
3552 gtk_container_add (new_zone, box);
3553 gtk_container_child_set (new_zone, box, "position", cpos, NULL);
3554
3555 g_object_unref (box);
3556
3557 if (zone && name)
3558 gnm_conf_set_toolbar_position (name, pos);
3559 }
3560
3561 static void
3562 cb_set_toolbar_position (GtkMenuItem *item, WBCGtk *gtk)
3563 {
3564 GtkToolbar *tb = g_object_get_data (G_OBJECT (item), "toolbar");
3565 GtkPositionType side = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (item), "side"));
3566
3567 if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (item)))
3568 set_toolbar_position (tb, side, gtk);
3569 }
3570
3571 static void
3572 cb_tcm_hide (GtkWidget *widget, GtkWidget *box)
3573 {
3574 gtk_widget_hide (box);
3575 }
3576
3577 static void
3578 toolbar_context_menu (GtkToolbar *tb, WBCGtk *gtk, GdkEvent *event)
3579 {
3580 GtkWidget *box = gtk_widget_get_parent (GTK_WIDGET (tb));
3581 GtkWidget *zone = gtk_widget_get_parent (GTK_WIDGET (box));
3582 GtkWidget *menu = gtk_menu_new ();
3583 GtkWidget *item;
3584 GSList *group = NULL;
3585 size_t ui;
3586
3587 static const struct {
3588 char const *text;
3589 GtkPositionType pos;
3590 } const pos_items[] = {
3591 { N_("Display toolbar above sheets"), GTK_POS_TOP },
3592 { N_("Display toolbar to the left of sheets"), GTK_POS_LEFT },
3593 { N_("Display toolbar to the right of sheets"), GTK_POS_RIGHT }
3594 };
3595
3596 if (gnm_debug_flag ("toolbar-size"))
3597 dump_size_tree (GTK_WIDGET (tb), GINT_TO_POINTER (0));
3598
3599 for (ui = 0; ui < G_N_ELEMENTS (pos_items); ui++) {
3600 char const *text = _(pos_items[ui].text);
3601 GtkPositionType pos = pos_items[ui].pos;
3602
3603 item = gtk_radio_menu_item_new_with_label (group, text);
3604 group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (item));
3605
3606 gtk_check_menu_item_set_active
3607 (GTK_CHECK_MENU_ITEM (item),
3608 (zone == gtk->toolbar_zones[pos]));
3609
3610 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
3611 g_object_set_data (G_OBJECT (item), "toolbar", tb);
3612 g_object_set_data (G_OBJECT (item), "side", GINT_TO_POINTER (pos));
3613 g_signal_connect (G_OBJECT (item), "activate",
3614 G_CALLBACK (cb_set_toolbar_position),
3615 gtk);
3616 }
3617
3618 item = gtk_separator_menu_item_new ();
3619 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
3620
3621 item = gtk_menu_item_new_with_label (_("Hide"));
3622 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
3623 g_signal_connect (G_OBJECT (item), "activate",
3624 G_CALLBACK (cb_tcm_hide),
3625 box);
3626
3627 gtk_widget_show_all (menu);
3628 gnumeric_popup_menu (GTK_MENU (menu), event);
3629 }
3630
3631 static gboolean
3632 cb_toolbar_button_press (GtkToolbar *tb, GdkEvent *event, WBCGtk *gtk)
3633 {
3634 if (event->type == GDK_BUTTON_PRESS &&
3635 event->button.button == 3) {
3636 toolbar_context_menu (tb, gtk, event);
3637 return TRUE;
3638 }
3639
3640 return FALSE;
3641 }
3642
3643 static gboolean
3644 cb_handlebox_button_press (GtkHandleBox *hdlbox, GdkEvent *event, WBCGtk *gtk)
3645 {
3646 if (event->type == GDK_BUTTON_PRESS &&
3647 event->button.button == 3) {
3648 GtkToolbar *tb = GTK_TOOLBAR (gtk_bin_get_child (GTK_BIN (hdlbox)));
3649 toolbar_context_menu (tb, gtk, event);
3650 return TRUE;
3651 }
3652
3653 return FALSE;
3654 }
3655
3656
3657 static void
3658 cb_toolbar_activate (GtkToggleAction *action, WBCGtk *wbcg)
3659 {
3660 wbcg_toggle_visibility (wbcg, action);
3661 }
3662
3663 static void
3664 cb_toolbar_box_visible (GtkWidget *box, G_GNUC_UNUSED GParamSpec *pspec,
3665 WBCGtk *wbcg)
3666 {
3667 GtkToggleAction *toggle_action = g_object_get_data (
3668 G_OBJECT (box), "toggle_action");
3669 char const *name = g_object_get_data (G_OBJECT (box), "name");
3670 gboolean visible = gtk_widget_get_visible (box);
3671
3672 gtk_toggle_action_set_active (toggle_action, visible);
3673 if (!wbcg->is_fullscreen) {
3674 /*
3675 * We do not persist changes made going-to/while-in/leaving
3676 * fullscreen mode.
3677 */
3678 gnm_conf_set_toolbar_visible (name, visible);
3679 }
3680 }
3681
3682 static struct ToolbarInfo {
3683 const char *name;
3684 const char *menu_text;
3685 const char *accel;
3686 } toolbar_info[] = {
3687 { "StandardToolbar", N_("Standard Toolbar"), "<control>7" },
3688 { "FormatToolbar", N_("Format Toolbar"), NULL },
3689 { "ObjectToolbar", N_("Object Toolbar"), NULL },
3690 { NULL, NULL, NULL }
3691 };
3692
3693
3694 static void
3695 cb_add_menus_toolbars (G_GNUC_UNUSED GtkUIManager *ui,
3696 GtkWidget *w, WBCGtk *gtk)
3697 {
3698 if (GTK_IS_TOOLBAR (w)) {
3699 WBCGtk *wbcg = (WBCGtk *)gtk;
3700 char const *name = gtk_widget_get_name (w);
3701 GtkToggleActionEntry entry;
3702 char *toggle_name = g_strconcat ("ViewMenuToolbar", name, NULL);
3703 char *tooltip = g_strdup_printf (_("Show/Hide toolbar %s"), _(name));
3704 gboolean visible = gnm_conf_get_toolbar_visible (name);
3705 int n = g_hash_table_size (wbcg->visibility_widgets);
3706 GtkWidget *vw;
3707 const struct ToolbarInfo *ti;
3708 GtkWidget *box;
3709 GtkPositionType pos = gnm_conf_get_toolbar_position (name);
3710
3711 // See bug 761142. This isn't supposed to be necessary.
3712 gtk_style_context_invalidate (gtk_widget_get_style_context (w));
3713
3714 if (gnm_conf_get_detachable_toolbars ()) {
3715 box = gtk_handle_box_new ();
3716 g_object_connect (box,
3717 "signal::child_attached", G_CALLBACK (cb_handlebox_dock_status), GINT_TO_POINTER (TRUE),
3718 "signal::child_detached", G_CALLBACK (cb_handlebox_dock_status), GINT_TO_POINTER (FALSE),
3719 NULL);
3720 } else
3721 box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
3722 g_signal_connect (G_OBJECT (w),
3723 "button_press_event",
3724 G_CALLBACK (cb_toolbar_button_press),
3725 gtk);
3726 g_signal_connect (G_OBJECT (box),
3727 "button_press_event",
3728 G_CALLBACK (cb_handlebox_button_press),
3729 gtk);
3730
3731 gtk_container_add (GTK_CONTAINER (box), w);
3732 gtk_widget_show_all (box);
3733 if (!visible)
3734 gtk_widget_hide (box);
3735 g_object_set_data (G_OBJECT (box), "toolbar-order",
3736 GINT_TO_POINTER (n));
3737 set_toolbar_position (GTK_TOOLBAR (w), pos, gtk);
3738
3739 g_signal_connect (box,
3740 "notify::visible",
3741 G_CALLBACK (cb_toolbar_box_visible),
3742 gtk);
3743 g_object_set_data_full (G_OBJECT (box), "name",
3744 g_strdup (name),
3745 (GDestroyNotify)g_free);
3746
3747 vw = box;
3748 g_hash_table_insert (wbcg->visibility_widgets,
3749 g_strdup (toggle_name),
3750 g_object_ref (vw));
3751
3752 gtk_toolbar_set_show_arrow (GTK_TOOLBAR (w), TRUE);
3753 gtk_toolbar_set_style (GTK_TOOLBAR (w), GTK_TOOLBAR_ICONS);
3754 gtk_toolbar_set_icon_size (GTK_TOOLBAR (w), GTK_ICON_SIZE_SMALL_TOOLBAR);
3755
3756 entry.name = toggle_name;
3757 entry.stock_id = NULL;
3758 entry.label = name;
3759 entry.accelerator = NULL;
3760 entry.tooltip = tooltip;
3761 entry.callback = G_CALLBACK (cb_toolbar_activate);
3762 entry.is_active = visible;
3763
3764 for (ti = toolbar_info; ti->name; ti++) {
3765 if (strcmp (name, ti->name) == 0) {
3766 entry.label = _(ti->menu_text);
3767 entry.accelerator = ti->accel;
3768 break;
3769 }
3770 }
3771
3772 gtk_action_group_add_toggle_actions (gtk->toolbar.actions,
3773 &entry, 1, wbcg);
3774 g_object_set_data (G_OBJECT (box), "toggle_action",
3775 gtk_action_group_get_action (gtk->toolbar.actions, toggle_name));
3776 gtk_ui_manager_add_ui (gtk->ui, gtk->toolbar.merge_id,
3777 "/menubar/View/Toolbars", toggle_name, toggle_name,
3778 GTK_UI_MANAGER_AUTO, FALSE);
3779 wbcg->hide_for_fullscreen =
3780 g_slist_prepend (wbcg->hide_for_fullscreen,
3781 gtk_action_group_get_action (gtk->toolbar.actions,
3782 toggle_name));
3783
3784 g_free (tooltip);
3785 g_free (toggle_name);
3786 } else {
3787 gtk_box_pack_start (GTK_BOX (gtk->menu_zone), w, FALSE, TRUE, 0);
3788 gtk_widget_show_all (w);
3789 }
3790 }
3791
3792 static void
3793 cb_clear_menu_tip (GOCmdContext *cc)
3794 {
3795 go_cmd_context_progress_message_set (cc, " ");
3796 }
3797
3798 static void
3799 cb_show_menu_tip (GtkWidget *proxy, GOCmdContext *cc)
3800 {
3801 GtkAction *action = g_object_get_data (G_OBJECT (proxy), "GtkAction");
3802 char *tip = NULL;
3803 g_object_get (action, "tooltip", &tip, NULL);
3804 if (tip) {
3805 go_cmd_context_progress_message_set (cc, _(tip));
3806 g_free (tip);
3807 } else
3808 cb_clear_menu_tip (cc);
3809 }
3810
3811 static void
3812 cb_connect_proxy (G_GNUC_UNUSED GtkUIManager *ui,
3813 GtkAction *action,
3814 GtkWidget *proxy,
3815 GOCmdContext *cc)
3816 {
3817 /* connect whether there is a tip or not it may change later */
3818 if (GTK_IS_MENU_ITEM (proxy)) {
3819 g_object_set_data (G_OBJECT (proxy), "GtkAction", action);
3820 g_object_connect (proxy,
3821 "signal::select", G_CALLBACK (cb_show_menu_tip), cc,
3822 "swapped_signal::deselect", G_CALLBACK (cb_clear_menu_tip), cc,
3823 NULL);
3824 }
3825 }
3826
3827 static void
3828 cb_disconnect_proxy (G_GNUC_UNUSED GtkUIManager *ui,
3829 G_GNUC_UNUSED GtkAction *action,
3830 GtkWidget *proxy,
3831 GOCmdContext *cc)
3832 {
3833 if (GTK_IS_MENU_ITEM (proxy)) {
3834 g_object_set_data (G_OBJECT (proxy), "GtkAction", NULL);
3835 g_object_disconnect (proxy,
3836 "any_signal::select", G_CALLBACK (cb_show_menu_tip), cc,
3837 "any_signal::deselect", G_CALLBACK (cb_clear_menu_tip), cc,
3838 NULL);
3839 }
3840 }
3841
3842 static void
3843 cb_post_activate (G_GNUC_UNUSED GtkUIManager *manager, GtkAction *action, WBCGtk *wbcg)
3844 {
3845 if (!wbcg_is_editing (wbcg) && strcmp(gtk_action_get_name (action), "EditGotoCellIndicator") != 0)
3846 wbcg_focus_cur_scg (wbcg);
3847 }
3848
3849 static void
3850 cb_wbcg_window_state_event (GtkWidget *widget,
3851 GdkEventWindowState *event,
3852 WBCGtk *wbcg)
3853 {
3854 gboolean new_val = (event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN) != 0;
3855 if (!(event->changed_mask & GDK_WINDOW_STATE_FULLSCREEN) ||
3856 new_val == wbcg->is_fullscreen ||
3857 wbcg->updating_ui)
3858 return;
3859
3860 wbc_gtk_set_toggle_action_state (wbcg, "ViewFullScreen", new_val);
3861
3862 if (new_val) {
3863 GSList *l;
3864
3865 wbcg->is_fullscreen = TRUE;
3866 for (l = wbcg->hide_for_fullscreen; l; l = l->next) {
3867 GtkToggleAction *ta = l->data;
3868 GOUndo *u;
3869 gboolean active = gtk_toggle_action_get_active (ta);
3870 u = go_undo_binary_new
3871 (ta, GUINT_TO_POINTER (active),
3872 (GOUndoBinaryFunc)gtk_toggle_action_set_active,
3873 NULL, NULL);
3874 wbcg->undo_for_fullscreen =
3875 go_undo_combine (wbcg->undo_for_fullscreen, u);
3876 gtk_toggle_action_set_active (ta, FALSE);
3877 }
3878 } else {
3879 if (wbcg->undo_for_fullscreen) {
3880 go_undo_undo (wbcg->undo_for_fullscreen);
3881 g_object_unref (wbcg->undo_for_fullscreen);
3882 wbcg->undo_for_fullscreen = NULL;
3883 }
3884 wbcg->is_fullscreen = FALSE;
3885 }
3886 }
3887
3888 /****************************************************************************/
3889
3890 static void
3891 cb_auto_expr_cell_changed (GtkWidget *item, WBCGtk *wbcg)
3892 {
3893 WorkbookView *wbv = wb_control_view (GNM_WBC (wbcg));
3894 const GnmEvalPos *ep;
3895 GnmExprTop const *texpr;
3896 GnmValue const *v;
3897
3898 if (wbcg->updating_ui)
3899 return;
3900
3901 ep = g_object_get_data (G_OBJECT (item), "evalpos");
3902
3903 g_object_set (wbv,
3904 "auto-expr-func", NULL,
3905 "auto-expr-descr", NULL,
3906 "auto-expr-eval-pos", ep,
3907 NULL);
3908
3909 /* Now we have the expression set. */
3910 texpr = wbv->auto_expr.dep.texpr;
3911 v = gnm_expr_top_get_constant (texpr);
3912 if (v)
3913 g_object_set (wbv,
3914 "auto-expr-descr", value_peek_string (v),
3915 NULL);
3916 }
3917
3918 static void
3919 cb_auto_expr_changed (GtkWidget *item, WBCGtk *wbcg)
3920 {
3921 const GnmFunc *func;
3922 const char *descr;
3923 WorkbookView *wbv = wb_control_view (GNM_WBC (wbcg));
3924
3925 if (wbcg->updating_ui)
3926 return;
3927
3928 func = g_object_get_data (G_OBJECT (item), "func");
3929 descr = g_object_get_data (G_OBJECT (item), "descr");
3930
3931 g_object_set (wbv,
3932 "auto-expr-func", func,
3933 "auto-expr-descr", descr,
3934 "auto-expr-eval-pos", NULL,
3935 NULL);
3936 }
3937
3938 static void
3939 cb_auto_expr_precision_toggled (GtkWidget *item, WBCGtk *wbcg)
3940 {
3941 WorkbookView *wbv = wb_control_view (GNM_WBC (wbcg));
3942 if (wbcg->updating_ui)
3943 return;
3944
3945 go_object_toggle (wbv, "auto-expr-max-precision");
3946 }
3947
3948 static void
3949 cb_auto_expr_insert_formula (WBCGtk *wbcg, gboolean below)
3950 {
3951 SheetControlGUI *scg = wbcg_cur_scg (wbcg);
3952 GnmRange const *selection = selection_first_range (scg_view (scg), NULL, NULL);
3953 GnmRange output;
3954 GnmRange *input;
3955 gboolean multiple, use_last_cr;
3956 data_analysis_output_t *dao;
3957 analysis_tools_data_auto_expression_t *specs;
3958
3959 g_return_if_fail (selection != NULL);
3960
3961 if (below) {
3962 multiple = (range_width (selection) > 1);
3963 output = *selection;
3964 range_normalize (&output);
3965 output.start.row = output.end.row;
3966 use_last_cr = (range_height (selection) > 1) && sheet_is_region_empty (scg_sheet (scg), &output);
3967 if (!use_last_cr) {
3968 if (range_translate (&output, scg_sheet (scg), 0, 1))
3969 return;
3970 if (multiple && gnm_sheet_get_last_col (scg_sheet (scg)) > output.end.col)
3971 output.end.col++;
3972 }
3973 input = gnm_range_dup (selection);
3974 range_normalize (input);
3975 if (use_last_cr)
3976 input->end.row--;
3977 } else {
3978 multiple = (range_height (selection) > 1);
3979 output = *selection;
3980 range_normalize (&output);
3981 output.start.col = output.end.col;
3982 use_last_cr = (range_width (selection) > 1) && sheet_is_region_empty (scg_sheet (scg), &output);
3983 if (!use_last_cr) {
3984 if (range_translate (&output, scg_sheet (scg), 1, 0))
3985 return;
3986 if (multiple && gnm_sheet_get_last_row (scg_sheet (scg)) > output.end.row)
3987 output.end.row++;
3988 }
3989 input = gnm_range_dup (selection);
3990 range_normalize (input);
3991 if (use_last_cr)
3992 input->end.col--;
3993 }
3994
3995
3996 dao = dao_init (NULL, RangeOutput);
3997 dao->start_col = output.start.col;
3998 dao->start_row = output.start.row;
3999 dao->cols = range_width (&output);
4000 dao->rows = range_height (&output);
4001 dao->sheet = scg_sheet (scg);
4002 dao->autofit_flag = FALSE;
4003 dao->put_formulas = TRUE;
4004
4005 specs = g_new0 (analysis_tools_data_auto_expression_t, 1);
4006 specs->base.wbc = GNM_WBC (wbcg);
4007 specs->base.input = g_slist_prepend (NULL, value_new_cellrange_r (scg_sheet (scg), input));
4008 g_free (input);
4009 specs->base.group_by = below ? GROUPED_BY_COL : GROUPED_BY_ROW;
4010 specs->base.labels = FALSE;
4011 specs->multiple = multiple;
4012 specs->below = below;
4013 specs->func = NULL;
4014 g_object_get (G_OBJECT (wb_control_view (GNM_WBC (wbcg))),
4015 "auto-expr-func", &(specs->func), NULL);
4016 if (specs->func == NULL) {
4017 specs->func = gnm_func_lookup_or_add_placeholder ("sum");
4018 gnm_func_ref (specs->func);
4019 }
4020
4021 cmd_analysis_tool (GNM_WBC (wbcg), scg_sheet (scg),
4022 dao, specs, analysis_tool_auto_expression_engine,
4023 TRUE);
4024 }
4025
4026 static void
4027 cb_auto_expr_insert_formula_below (G_GNUC_UNUSED GtkWidget *item, WBCGtk *wbcg)
4028 {
4029 cb_auto_expr_insert_formula (wbcg, TRUE);
4030 }
4031
4032 static void
4033 cb_auto_expr_insert_formula_to_side (G_GNUC_UNUSED GtkWidget *item, WBCGtk *wbcg)
4034 {
4035 cb_auto_expr_insert_formula (wbcg, FALSE);
4036 }
4037
4038
4039 static gboolean
4040 cb_select_auto_expr (GtkWidget *widget, GdkEvent *event, WBCGtk *wbcg)
4041 {
4042 /*
4043 * WARNING * WARNING * WARNING
4044 *
4045 * Keep the functions in lower case.
4046 * We currently register the functions in lower case and some locales
4047 * (notably tr_TR) do not have the same encoding for tolower that
4048 * locale C does.
4049 *
4050 * eg tolower ('I') != 'i'
4051 * Which would break function lookup when looking up for function 'selectIon'
4052 * when it was registered as 'selection'
4053 *
4054 * WARNING * WARNING * WARNING
4055 */
4056 static struct {
4057 char const * const displayed_name;
4058 char const * const function;
4059 } const quick_compute_routines [] = {
4060 { N_("Sum"), "sum" },
4061 { N_("Min"), "min" },
4062 { N_("Max"), "max" },
4063 { N_("Average"), "average" },
4064 { N_("Count"), "count" },
4065 { NULL, NULL }
4066 };
4067
4068 WorkbookView *wbv = wb_control_view (GNM_WBC (wbcg));
4069 Sheet *sheet = wb_view_cur_sheet (wbv);
4070 GtkWidget *item, *menu;
4071 int i;
4072 char *cell_item;
4073 GnmCellPos const *pos;
4074 GnmEvalPos ep;
4075
4076 if (event->button.button != 3)
4077 return FALSE;
4078
4079 menu = gtk_menu_new ();
4080
4081 for (i = 0; quick_compute_routines[i].displayed_name; i++) {
4082 GnmParsePos pp;
4083 char const *fname = quick_compute_routines[i].function;
4084 char const *dispname =
4085 _(quick_compute_routines[i].displayed_name);
4086 GnmExprTop const *new_auto_expr;
4087 GtkWidget *item;
4088 char *expr_txt;
4089
4090 /* Test the expression... */
4091 parse_pos_init (&pp, sheet->workbook, sheet, 0, 0);
4092 expr_txt = g_strconcat (fname, "(",
4093 parsepos_as_string (&pp),
4094 ")", NULL);
4095 new_auto_expr = gnm_expr_parse_str
4096 (expr_txt, &pp, GNM_EXPR_PARSE_DEFAULT,
4097 sheet_get_conventions (sheet), NULL);
4098 g_free (expr_txt);
4099 if (!new_auto_expr)
4100 continue;
4101 gnm_expr_top_unref (new_auto_expr);
4102
4103 item = gtk_menu_item_new_with_label (dispname);
4104 g_object_set_data (G_OBJECT (item),
4105 "func", gnm_func_lookup (fname, NULL));
4106 g_object_set_data (G_OBJECT (item),
4107 "descr", (gpointer)dispname);
4108 g_signal_connect (G_OBJECT (item),
4109 "activate",
4110 G_CALLBACK (cb_auto_expr_changed), wbcg);
4111 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
4112 gtk_widget_show (item);
4113 }
4114
4115 item = gtk_separator_menu_item_new ();
4116 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
4117 gtk_widget_show (item);
4118
4119 pos = &(scg_view (wbcg_cur_scg (wbcg)))->edit_pos;
4120 eval_pos_init_pos (&ep, sheet, pos);
4121 cell_item = g_strdup_printf (_("Content of %s"), cellpos_as_string (pos));
4122 item = gtk_menu_item_new_with_label (cell_item);
4123 g_free (cell_item);
4124 g_object_set_data_full (G_OBJECT (item),
4125 "evalpos", g_memdup (&ep, sizeof (ep)),
4126 (GDestroyNotify)g_free);
4127 g_signal_connect (G_OBJECT (item), "activate",
4128 G_CALLBACK (cb_auto_expr_cell_changed), wbcg);
4129 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
4130 gtk_widget_show (item);
4131
4132 item = gtk_separator_menu_item_new ();
4133 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
4134 gtk_widget_show (item);
4135
4136 item = gtk_check_menu_item_new_with_label (_("Use Maximum Precision"));
4137 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item),
4138 wbv->auto_expr.use_max_precision);
4139 g_signal_connect (G_OBJECT (item), "activate",
4140 G_CALLBACK (cb_auto_expr_precision_toggled), wbcg);
4141 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
4142 gtk_widget_show (item);
4143
4144 item = gtk_separator_menu_item_new ();
4145 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
4146 gtk_widget_show (item);
4147
4148 item = gtk_menu_item_new_with_label (_("Insert Formula Below"));
4149 g_signal_connect (G_OBJECT (item), "activate",
4150 G_CALLBACK (cb_auto_expr_insert_formula_below), wbcg);
4151 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
4152 gtk_widget_show (item);
4153
4154 item = gtk_menu_item_new_with_label (_("Insert Formula to Side"));
4155 g_signal_connect (G_OBJECT (item), "activate",
4156 G_CALLBACK (cb_auto_expr_insert_formula_to_side), wbcg);
4157 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
4158 gtk_widget_show (item);
4159
4160 gnumeric_popup_menu (GTK_MENU (menu), event);
4161 return TRUE;
4162 }
4163
4164 static void
4165 wbc_gtk_create_status_area (WBCGtk *wbcg)
4166 {
4167 GtkWidget *ebox;
4168
4169 g_object_ref (wbcg->auto_expr_label);
4170 gtk_label_set_max_width_chars (GTK_LABEL (wbcg->auto_expr_label),
4171 strlen (AUTO_EXPR_SAMPLE));
4172 gtk_widget_set_size_request
4173 (wbcg->auto_expr_label,
4174 gnm_widget_measure_string (GTK_WIDGET (wbcg->toplevel),
4175 AUTO_EXPR_SAMPLE),
4176 -1);
4177
4178 gtk_widget_set_size_request
4179 (wbcg->status_text,
4180 gnm_widget_measure_string (GTK_WIDGET (wbcg->toplevel),
4181 "W") * 5,
4182 -1);
4183 ebox = GET_GUI_ITEM ("auto_expr_event_box");
4184 gtk_style_context_add_class (gtk_widget_get_style_context (ebox),
4185 "auto-expr");
4186 g_signal_connect (G_OBJECT (ebox),
4187 "button_press_event",
4188 G_CALLBACK (cb_select_auto_expr), wbcg);
4189
4190 g_hash_table_insert (wbcg->visibility_widgets,
4191 g_strdup ("ViewStatusbar"),
4192 g_object_ref (wbcg->status_area));
4193
4194 /* disable statusbar by default going to fullscreen */
4195 wbcg->hide_for_fullscreen =
4196 g_slist_prepend (wbcg->hide_for_fullscreen,
4197 wbcg_find_action (wbcg, "ViewStatusbar"));
4198 g_assert (wbcg->hide_for_fullscreen->data);
4199 }
4200
4201 /****************************************************************************/
4202
4203 static void
4204 cb_file_history_activate (GObject *action, WBCGtk *wbcg)
4205 {
4206 gui_file_read (wbcg, g_object_get_data (action, "uri"), NULL, NULL);
4207 }
4208
4209 static void
4210 wbc_gtk_reload_recent_file_menu (WBCGtk *wbcg)
4211 {
4212 WBCGtk *gtk = (WBCGtk *)wbcg;
4213 GSList *history, *ptr;
4214 unsigned i;
4215 gboolean any_history;
4216 GtkAction *full_history;
4217
4218 if (gtk->file_history.merge_id != 0)
4219 gtk_ui_manager_remove_ui (gtk->ui, gtk->file_history.merge_id);
4220 gtk->file_history.merge_id = gtk_ui_manager_new_merge_id (gtk->ui);
4221
4222 if (gtk->file_history.actions != NULL) {
4223 gtk_ui_manager_remove_action_group (gtk->ui,
4224 gtk->file_history.actions);
4225 g_object_unref (gtk->file_history.actions);
4226 }
4227 gtk->file_history.actions = gtk_action_group_new ("FileHistory");
4228
4229 /* create the actions */
4230 history = gnm_app_history_get_list (3);
4231 any_history = (history != NULL);
4232 for (i = 1, ptr = history; ptr != NULL ; ptr = ptr->next, i++) {
4233 GtkActionEntry entry;
4234 GtkAction *action;
4235 char const *uri = ptr->data;
4236 char *name = g_strdup_printf ("FileHistoryEntry%d", i);
4237 char *label = gnm_history_item_label (uri, i);
4238 char *filename = go_filename_from_uri (uri);
4239 char *filename_utf8 = filename ? g_filename_to_utf8 (filename, -1, NULL, NULL, NULL) : NULL;
4240 char *tooltip = g_strdup_printf (_("Open %s"), filename_utf8 ? filename_utf8 : uri);
4241
4242 entry.name = name;
4243 entry.stock_id = NULL;
4244 entry.label = label;
4245 entry.accelerator = NULL;
4246 entry.tooltip = tooltip;
4247 entry.callback = G_CALLBACK (cb_file_history_activate);
4248 gtk_action_group_add_actions (gtk->file_history.actions,
4249 &entry, 1, (WBCGtk *)wbcg);
4250 action = gtk_action_group_get_action (gtk->file_history.actions,
4251 name);
4252 g_object_set_data_full (G_OBJECT (action), "uri",
4253 g_strdup (uri), (GDestroyNotify)g_free);
4254
4255 g_free (name);
4256 g_free (label);
4257 g_free (filename);
4258 g_free (filename_utf8);
4259 g_free (tooltip);
4260 }
4261 g_slist_free_full (history, (GDestroyNotify)g_free);
4262
4263 gtk_ui_manager_insert_action_group (gtk->ui, gtk->file_history.actions, 0);
4264
4265 /* merge them in */
4266 while (i-- > 1) {
4267 char *name = g_strdup_printf ("FileHistoryEntry%d", i);
4268 gtk_ui_manager_add_ui (gtk->ui, gtk->file_history.merge_id,
4269 "/menubar/File/FileHistory", name, name,
4270 GTK_UI_MANAGER_AUTO, TRUE);
4271 g_free (name);
4272 }
4273
4274 full_history = wbcg_find_action (wbcg, "FileHistoryFull");
4275 g_object_set (G_OBJECT (full_history), "sensitive", any_history, NULL);
4276 }
4277
4278 static void
4279 cb_new_from_template (GObject *action, WBCGtk *wbcg)
4280 {
4281 const char *uri = g_object_get_data (action, "uri");
4282 gnm_gui_file_template (wbcg, uri);
4283 }
4284
4285 static void
4286 add_template_dir (const char *path, GHashTable *h)
4287 {
4288 GDir *dir;
4289 const char *name;
4290
4291 dir = g_dir_open (path, 0, NULL);
4292 if (!dir)
4293 return;
4294
4295 while ((name = g_dir_read_name (dir))) {
4296 char *fullname = g_build_filename (path, name, NULL);
4297
4298 /*
4299 * Unconditionally remove, so we can link to /dev/null
4300 * and cause a system file to be hidden.
4301 */
4302 g_hash_table_remove (h, name);
4303
4304 if (g_file_test (fullname, G_FILE_TEST_IS_REGULAR)) {
4305 char *uri = go_filename_to_uri (fullname);
4306 g_hash_table_insert (h, g_strdup (name), uri);
4307 }
4308 g_free (fullname);
4309 }
4310 g_dir_close (dir);
4311 }
4312
4313 static void
4314 wbc_gtk_reload_templates (WBCGtk *gtk)
4315 {
4316 unsigned i;
4317 GSList *l, *names;
4318 char *path;
4319 GHashTable *h;
4320
4321 if (gtk->templates.merge_id != 0)
4322 gtk_ui_manager_remove_ui (gtk->ui, gtk->templates.merge_id);
4323 gtk->templates.merge_id = gtk_ui_manager_new_merge_id (gtk->ui);
4324
4325 if (gtk->templates.actions != NULL) {
4326 gtk_ui_manager_remove_action_group (gtk->ui,
4327 gtk->templates.actions);
4328 g_object_unref (gtk->templates.actions);
4329 }
4330 gtk->templates.actions = gtk_action_group_new ("TemplateList");
4331
4332 gtk_ui_manager_insert_action_group (gtk->ui, gtk->templates.actions, 0);
4333
4334 h = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
4335
4336 path = g_build_filename (gnm_sys_data_dir (), "templates", NULL);
4337 add_template_dir (path, h);
4338 g_free (path);
4339
4340 /* Possibly override the above with user templates without version. */
4341 path = g_build_filename (gnm_usr_dir (FALSE), "templates", NULL);
4342 add_template_dir (path, h);
4343 g_free (path);
4344
4345 /* Possibly override the above with user templates with version. */
4346 path = g_build_filename (gnm_usr_dir (TRUE), "templates", NULL);
4347 add_template_dir (path, h);
4348 g_free (path);
4349
4350 names = g_slist_sort (go_hash_keys (h), (GCompareFunc)g_utf8_collate);
4351
4352 for (i = 1, l = names; l; l = l->next) {
4353 const char *uri = g_hash_table_lookup (h, l->data);
4354 GString *label = g_string_new (NULL);
4355 GtkActionEntry entry;
4356 char *gname;
4357 const char *gpath;
4358 char *basename = go_basename_from_uri (uri);
4359 const char *s;
4360 GtkAction *action;
4361
4362 if (i < 10) g_string_append_c (label, '_');
4363 g_string_append_printf (label, "%d ", i);
4364
4365 for (s = basename; *s; s++) {
4366 if (*s == '_') g_string_append_c (label, '_');
4367 g_string_append_c (label, *s);
4368 }
4369
4370 entry.name = gname = g_strdup_printf ("Template%d", i);
4371 entry.stock_id = NULL;
4372 entry.label = label->str;
4373 entry.accelerator = NULL;
4374 entry.tooltip = NULL;
4375 entry.callback = G_CALLBACK (cb_new_from_template);
4376
4377 gtk_action_group_add_actions (gtk->templates.actions,
4378 &entry, 1, gtk);
4379
4380 action = gtk_action_group_get_action (gtk->templates.actions,
4381 entry.name);
4382
4383 g_object_set_data_full (G_OBJECT (action), "uri",
4384 g_strdup (uri), (GDestroyNotify)g_free);
4385
4386
4387 gpath = "/menubar/File/Templates";
4388 gtk_ui_manager_add_ui (gtk->ui, gtk->templates.merge_id,
4389 gpath, gname, gname,
4390 GTK_UI_MANAGER_AUTO, FALSE);
4391
4392 g_string_free (label, TRUE);
4393 g_free (gname);
4394 g_free (basename);
4395 i++;
4396 }
4397
4398 g_slist_free (names);
4399 g_hash_table_destroy (h);
4400 }
4401
4402 gboolean
4403 wbc_gtk_load_templates (WBCGtk *wbcg)
4404 {
4405 if (wbcg->templates.merge_id == 0) {
4406 wbc_gtk_reload_templates (wbcg);
4407 }
4408
4409 wbcg->template_loader_handler = 0;
4410 return FALSE;
4411 }
4412
4413 static void
4414 wbcg_set_toplevel (WBCGtk *wbcg, GtkWidget *w)
4415 {
4416 static GtkTargetEntry const drag_types[] = {
4417 { (char *) "text/uri-list", 0, TARGET_URI_LIST },
4418 { (char *) "GNUMERIC_SHEET", 0, TARGET_SHEET },
4419 { (char *) "GNUMERIC_SAME_PROC", GTK_TARGET_SAME_APP, 0 }
4420 };
4421
4422 g_return_if_fail (wbcg->toplevel == NULL);
4423
4424 wbcg->toplevel = w;
4425 w = GTK_WIDGET (wbcg_toplevel (wbcg));
4426 g_return_if_fail (GTK_IS_WINDOW (w));
4427
4428 g_object_set (G_OBJECT (w),
4429 "resizable", TRUE,
4430 NULL);
4431
4432 g_signal_connect_data (w, "delete_event",
4433 G_CALLBACK (wbc_gtk_close), wbcg, NULL,
4434 G_CONNECT_AFTER | G_CONNECT_SWAPPED);
4435 g_signal_connect_after (w, "set_focus",
4436 G_CALLBACK (cb_set_focus), wbcg);
4437 g_signal_connect (w, "scroll-event",
4438 G_CALLBACK (cb_scroll_wheel), wbcg);
4439 g_signal_connect (w, "realize",
4440 G_CALLBACK (cb_realize), wbcg);
4441 g_signal_connect (w, "screen-changed",
4442 G_CALLBACK (cb_screen_changed), NULL);
4443 cb_screen_changed (w);
4444
4445 /* Setup a test of Drag and Drop */
4446 gtk_drag_dest_set (GTK_WIDGET (w),
4447 GTK_DEST_DEFAULT_ALL, drag_types, G_N_ELEMENTS (drag_types),
4448 GDK_ACTION_COPY | GDK_ACTION_MOVE);
4449 gtk_drag_dest_add_image_targets (GTK_WIDGET (w));
4450 gtk_drag_dest_add_text_targets (GTK_WIDGET (w));
4451 g_object_connect (G_OBJECT (w),
4452 "signal::drag-leave", G_CALLBACK (cb_wbcg_drag_leave), wbcg,
4453 "signal::drag-data-received", G_CALLBACK (cb_wbcg_drag_data_received), wbcg,
4454 "signal::drag-motion", G_CALLBACK (cb_wbcg_drag_motion), wbcg,
4455 #if 0
4456 "signal::drag-data-get", G_CALLBACK (wbcg_drag_data_get), wbc,
4457 #endif
4458 NULL);
4459 }
4460
4461 /***************************************************************************/
4462
4463 static void
4464 wbc_gtk_get_property (GObject *object, guint property_id,
4465 GValue *value, GParamSpec *pspec)
4466 {
4467 WBCGtk *wbcg = (WBCGtk *)object;
4468
4469 switch (property_id) {
4470 case WBG_GTK_PROP_AUTOSAVE_PROMPT:
4471 g_value_set_boolean (value, wbcg->autosave_prompt);
4472 break;
4473 case WBG_GTK_PROP_AUTOSAVE_TIME:
4474 g_value_set_int (value, wbcg->autosave_time);
4475 break;
4476 default:
4477 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
4478 break;
4479 }
4480 }
4481
4482 static void
4483 wbc_gtk_set_property (GObject *object, guint property_id,
4484 const GValue *value, GParamSpec *pspec)
4485 {
4486 WBCGtk *wbcg = (WBCGtk *)object;
4487
4488 switch (property_id) {
4489 case WBG_GTK_PROP_AUTOSAVE_PROMPT:
4490 wbcg->autosave_prompt = g_value_get_boolean (value);
4491 break;
4492 case WBG_GTK_PROP_AUTOSAVE_TIME:
4493 wbcg_set_autosave_time (wbcg, g_value_get_int (value));
4494 break;
4495 default:
4496 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
4497 break;
4498 }
4499 }
4500
4501 static void
4502 wbc_gtk_finalize (GObject *obj)
4503 {
4504 WBCGtk *wbcg = WBC_GTK (obj);
4505
4506 if (wbcg->idle_update_style_feedback != 0)
4507 g_source_remove (wbcg->idle_update_style_feedback);
4508
4509 if (wbcg->template_loader_handler != 0) {
4510 g_source_remove (wbcg->template_loader_handler);
4511 wbcg->template_loader_handler = 0;
4512 }
4513
4514 if (wbcg->file_history.merge_id != 0)
4515 gtk_ui_manager_remove_ui (wbcg->ui, wbcg->file_history.merge_id);
4516 g_clear_object (&wbcg->file_history.actions);
4517
4518 if (wbcg->toolbar.merge_id != 0)
4519 gtk_ui_manager_remove_ui (wbcg->ui, wbcg->toolbar.merge_id);
4520 g_clear_object (&wbcg->toolbar.actions);
4521
4522 if (wbcg->windows.merge_id != 0)
4523 gtk_ui_manager_remove_ui (wbcg->ui, wbcg->windows.merge_id);
4524 g_clear_object (&wbcg->windows.actions);
4525
4526 if (wbcg->templates.merge_id != 0)
4527 gtk_ui_manager_remove_ui (wbcg->ui, wbcg->templates.merge_id);
4528 g_clear_object (&wbcg->templates.actions);
4529
4530 {
4531 GSList *l, *uis = go_hash_keys (wbcg->custom_uis);
4532 for (l = uis; l; l = l->next) {
4533 GnmAppExtraUI *extra_ui = l->data;
4534 cb_remove_custom_ui (NULL, extra_ui, wbcg);
4535 }
4536 g_slist_free (uis);
4537 }
4538
4539 g_hash_table_destroy (wbcg->custom_uis);
4540 wbcg->custom_uis = NULL;
4541
4542 g_clear_object (&wbcg->zoom_vaction);
4543 g_clear_object (&wbcg->zoom_haction);
4544 g_clear_object (&wbcg->borders);
4545 g_clear_object (&wbcg->fore_color);
4546 g_clear_object (&wbcg->back_color);
4547 g_clear_object (&wbcg->font_name_haction);
4548 g_clear_object (&wbcg->font_name_vaction);
4549 g_clear_object (&wbcg->redo_haction);
4550 g_clear_object (&wbcg->redo_vaction);
4551 g_clear_object (&wbcg->undo_haction);
4552 g_clear_object (&wbcg->undo_vaction);
4553 g_clear_object (&wbcg->halignment);
4554 g_clear_object (&wbcg->valignment);
4555 g_clear_object (&wbcg->actions);
4556 g_clear_object (&wbcg->permanent_actions);
4557 g_clear_object (&wbcg->font_actions);
4558 g_clear_object (&wbcg->data_only_actions);
4559 g_clear_object (&wbcg->semi_permanent_actions);
4560 g_clear_object (&wbcg->ui);
4561
4562 /* Disconnect signals that would attempt to change things during
4563 * destruction.
4564 */
4565
4566 wbcg_autosave_cancel (wbcg);
4567
4568 if (wbcg->bnotebook != NULL)
4569 g_signal_handlers_disconnect_by_func (
4570 G_OBJECT (wbcg->bnotebook),
4571 G_CALLBACK (cb_notebook_switch_page), wbcg);
4572 g_clear_object (&wbcg->bnotebook);
4573
4574 g_signal_handlers_disconnect_by_func (
4575 G_OBJECT (wbcg->toplevel),
4576 G_CALLBACK (cb_set_focus), wbcg);
4577
4578 wbcg_auto_complete_destroy (wbcg);
4579
4580 gtk_window_set_focus (wbcg_toplevel (wbcg), NULL);
4581
4582 if (wbcg->toplevel != NULL) {
4583 gtk_widget_destroy (wbcg->toplevel);
4584 wbcg->toplevel = NULL;
4585 }
4586
4587 if (wbcg->font_desc) {
4588 pango_font_description_free (wbcg->font_desc);
4589 wbcg->font_desc = NULL;
4590 }
4591
4592 g_clear_object (&wbcg->auto_expr_label);
4593
4594 g_hash_table_destroy (wbcg->visibility_widgets);
4595 g_clear_object (&wbcg->undo_for_fullscreen);
4596
4597 g_slist_free (wbcg->hide_for_fullscreen);
4598 wbcg->hide_for_fullscreen = NULL;
4599
4600
4601 g_free (wbcg->preferred_geometry);
4602 wbcg->preferred_geometry = NULL;
4603
4604 g_clear_object (&wbcg->gui);
4605
4606 parent_class->finalize (obj);
4607 }
4608
4609 /***************************************************************************/
4610
4611 typedef struct {
4612 GnmExprEntry *entry;
4613 GogDataset *dataset;
4614 int dim_i;
4615 gboolean suppress_update;
4616 GogDataType data_type;
4617 gboolean changed;
4618
4619 gulong dataset_changed_handler;
4620 gulong entry_update_handler;
4621 guint idle;
4622 } GraphDimEditor;
4623
4624 static void
4625 cb_graph_dim_editor_update (GnmExprEntry *gee,
4626 G_GNUC_UNUSED gboolean user_requested,
4627 GraphDimEditor *editor)
4628 {
4629 GOData *data = NULL;
4630 Sheet *sheet;
4631 SheetControlGUI *scg;
4632 editor->changed = FALSE;
4633
4634 /* Ignore changes while we are insensitive. useful for displaying
4635 * values, without storing them as Data. Also ignore updates if the
4636 * dataset has been cleared via the weakref handler */
4637 if (!gtk_widget_is_sensitive (GTK_WIDGET (gee)) ||
4638 editor->dataset == NULL)
4639 return;
4640
4641 scg = gnm_expr_entry_get_scg (gee);
4642 sheet = scg_sheet (scg);
4643
4644 /* If we are setting something */
4645 if (!gnm_expr_entry_is_blank (editor->entry)) {
4646 GnmParsePos pos;
4647 GnmParseError perr;
4648 GnmExprTop const *texpr;
4649 GnmExprParseFlags flags =
4650 (editor->data_type == GOG_DATA_VECTOR)?
4651 GNM_EXPR_PARSE_PERMIT_MULTIPLE_EXPRESSIONS |
4652 GNM_EXPR_PARSE_UNKNOWN_NAMES_ARE_STRINGS:
4653 GNM_EXPR_PARSE_UNKNOWN_NAMES_ARE_STRINGS;
4654
4655 parse_error_init (&perr);
4656 /* Setting start_sel=FALSE to avoid */
4657 /* https://bugzilla.gnome.org/show_bug.cgi?id=658223 */
4658 texpr = gnm_expr_entry_parse (editor->entry,
4659 parse_pos_init_sheet (&pos, sheet),
4660 &perr, FALSE, flags);
4661
4662 /* TODO : add some error dialogs split out
4663 * the code in workbook_edit to add parens. */
4664 if (texpr == NULL) {
4665 if (editor->data_type == GOG_DATA_SCALAR)
4666 texpr = gnm_expr_top_new_constant (
4667 value_new_string (
4668 gnm_expr_entry_get_text (editor->entry)));
4669 else {
4670 g_return_if_fail (perr.err != NULL);
4671
4672 wb_control_validation_msg (GNM_WBC (scg_wbcg (scg)),
4673 GNM_VALIDATION_STYLE_INFO, NULL, perr.err->message);
4674 parse_error_free (&perr);
4675 gtk_editable_select_region (GTK_EDITABLE (gnm_expr_entry_get_entry (editor->entry)), 0, G_MAXINT);
4676 editor->changed = TRUE;
4677 return;
4678 }
4679 }
4680
4681 switch (editor->data_type) {
4682 case GOG_DATA_SCALAR:
4683 data = gnm_go_data_scalar_new_expr (sheet, texpr);
4684 break;
4685 case GOG_DATA_VECTOR:
4686 data = gnm_go_data_vector_new_expr (sheet, texpr);
4687 break;
4688 case GOG_DATA_MATRIX:
4689 data = gnm_go_data_matrix_new_expr (sheet, texpr);
4690 }
4691 }
4692
4693 /* The SheetObjectGraph does the magic to link things in */
4694 editor->suppress_update = TRUE;
4695 gog_dataset_set_dim (editor->dataset, editor->dim_i, data, NULL);
4696 editor->suppress_update = FALSE;
4697 }
4698
4699 static gboolean
4700 cb_update_idle (GraphDimEditor *editor)
4701 {
4702 cb_graph_dim_editor_update (editor->entry, FALSE, editor);
4703 editor->idle = 0;
4704 return FALSE;
4705 }
4706
4707 static void
4708 graph_dim_cancel_idle (GraphDimEditor *editor)
4709 {
4710 if (editor->idle) {
4711 g_source_remove (editor->idle);
4712 editor->idle = 0;
4713 }
4714 }
4715
4716 static gboolean
4717 cb_graph_dim_entry_focus_out_event (G_GNUC_UNUSED GtkEntry *ignored,
4718 G_GNUC_UNUSED GdkEventFocus *event,
4719 GraphDimEditor *editor)
4720 {
4721 if (!editor->changed)
4722 return FALSE;
4723 graph_dim_cancel_idle (editor);
4724 editor->idle = g_idle_add ((GSourceFunc) cb_update_idle, editor);
4725
4726 return FALSE;
4727 }
4728
4729 static void
4730 cb_graph_dim_entry_changed (GraphDimEditor *editor)
4731 {
4732 editor->changed = TRUE;
4733 }
4734
4735 static void
4736 set_entry_contents (GnmExprEntry *entry, GOData *val)
4737 {
4738 if (GNM_IS_GO_DATA_SCALAR (val)) {
4739 GnmValue const *v = gnm_expr_top_get_constant (gnm_go_data_get_expr (val));
4740 if (v && VALUE_IS_NUMBER (v)) {
4741 double d = go_data_get_scalar_value (val);
4742 GODateConventions const *date_conv = go_data_date_conv (val);
4743 gog_data_editor_set_value_double (GOG_DATA_EDITOR (entry),
4744 d, date_conv);
4745 return;
4746 }
4747 }
4748
4749 if (GO_IS_DATA_SCALAR (val) && go_data_has_value (val)) {
4750 double d = go_data_get_scalar_value (val);
4751 GODateConventions const *date_conv = go_data_date_conv (val);
4752 gog_data_editor_set_value_double (GOG_DATA_EDITOR (entry),
4753 d, date_conv);
4754 return;
4755 }
4756
4757 {
4758 SheetControlGUI *scg = gnm_expr_entry_get_scg (entry);
4759 Sheet const *sheet = scg_sheet (scg);
4760 char *txt = go_data_serialize (val, (gpointer)sheet->convs);
4761 gnm_expr_entry_load_from_text (entry, txt);
4762 g_free (txt);
4763 }
4764 }
4765
4766 static void
4767 cb_dataset_changed (GogDataset *dataset,
4768 gboolean resize,
4769 GraphDimEditor *editor)
4770 {
4771 GOData *val = gog_dataset_get_dim (dataset, editor->dim_i);
4772 if (val != NULL && !editor->suppress_update) {
4773 g_signal_handler_block (editor->entry,
4774 editor->entry_update_handler);
4775 set_entry_contents (editor->entry, val);
4776 g_signal_handler_unblock (editor->entry,
4777 editor->entry_update_handler);
4778 }
4779 }
4780
4781 static void
4782 cb_dim_editor_weakref_notify (GraphDimEditor *editor, GogDataset *dataset)
4783 {
4784 g_return_if_fail (editor->dataset == dataset);
4785 editor->dataset = NULL;
4786 }
4787
4788 static void
4789 graph_dim_editor_free (GraphDimEditor *editor)
4790 {
4791 graph_dim_cancel_idle (editor);
4792 if (editor->dataset) {
4793 g_signal_handler_disconnect (editor->dataset, editor->dataset_changed_handler);
4794 g_object_weak_unref (G_OBJECT (editor->dataset),
4795 (GWeakNotify) cb_dim_editor_weakref_notify, editor);
4796 }
4797 g_free (editor);
4798 }
4799
4800 static GogDataEditor *
4801 wbcg_data_allocator_editor (GogDataAllocator *dalloc,
4802 GogDataset *dataset, int dim_i, GogDataType data_type)
4803 {
4804 WBCGtk *wbcg = WBC_GTK (dalloc);
4805 GraphDimEditor *editor;
4806 GOData *val;
4807
4808 editor = g_new (GraphDimEditor, 1);
4809 editor->dataset = dataset;
4810 editor->dim_i = dim_i;
4811 editor->suppress_update = FALSE;
4812 editor->data_type = data_type;
4813 editor->entry = gnm_expr_entry_new (wbcg, TRUE);
4814 editor->idle = 0;
4815 editor->changed = FALSE;
4816 g_object_weak_ref (G_OBJECT (editor->dataset),
4817 (GWeakNotify) cb_dim_editor_weakref_notify, editor);
4818
4819 gnm_expr_entry_set_update_policy (editor->entry,
4820 GNM_UPDATE_DISCONTINUOUS);
4821
4822 val = gog_dataset_get_dim (dataset, dim_i);
4823 if (val != NULL) {
4824 set_entry_contents (editor->entry, val);
4825 }
4826
4827 gnm_expr_entry_set_flags (editor->entry, GNM_EE_FORCE_ABS_REF, GNM_EE_MASK);
4828
4829 editor->entry_update_handler = g_signal_connect (G_OBJECT (editor->entry),
4830 "update",
4831 G_CALLBACK (cb_graph_dim_editor_update), editor);
4832 g_signal_connect (G_OBJECT (gnm_expr_entry_get_entry (editor->entry)),
4833 "focus-out-event",
4834 G_CALLBACK (cb_graph_dim_entry_focus_out_event), editor);
4835 g_signal_connect_swapped (G_OBJECT (gnm_expr_entry_get_entry (editor->entry)),
4836 "changed",
4837 G_CALLBACK (cb_graph_dim_entry_changed), editor);
4838 editor->dataset_changed_handler = g_signal_connect (G_OBJECT (editor->dataset),
4839 "changed", G_CALLBACK (cb_dataset_changed), editor);
4840 g_object_set_data_full (G_OBJECT (editor->entry),
4841 "editor", editor, (GDestroyNotify) graph_dim_editor_free);
4842
4843 return GOG_DATA_EDITOR (editor->entry);
4844 }
4845
4846 static void
4847 wbcg_data_allocator_allocate (GogDataAllocator *dalloc, GogPlot *plot)
4848 {
4849 SheetControlGUI *scg = wbcg_cur_scg (WBC_GTK (dalloc));
4850 sv_selection_to_plot (scg_view (scg), plot);
4851 }
4852
4853
4854 static void
4855 wbcg_go_plot_data_allocator_init (GogDataAllocatorClass *iface)
4856 {
4857 iface->editor = wbcg_data_allocator_editor;
4858 iface->allocate = wbcg_data_allocator_allocate;
4859 }
4860
4861 /*************************************************************************/
4862 static char *
4863 wbcg_get_password (GOCmdContext *cc, char const* filename)
4864 {
4865 WBCGtk *wbcg = WBC_GTK (cc);
4866
4867 return dialog_get_password (wbcg_toplevel (wbcg), filename);
4868 }
4869 static void
4870 wbcg_set_sensitive (GOCmdContext *cc, gboolean sensitive)
4871 {
4872 GtkWindow *toplevel = wbcg_toplevel (WBC_GTK (cc));
4873 if (toplevel != NULL)
4874 gtk_widget_set_sensitive (GTK_WIDGET (toplevel), sensitive);
4875 }
4876 static void
4877 wbcg_error_error (GOCmdContext *cc, GError *err)
4878 {
4879 go_gtk_notice_dialog (wbcg_toplevel (WBC_GTK (cc)),
4880 GTK_MESSAGE_ERROR,
4881 "%s", err->message);
4882 }
4883
4884 static void
4885 wbcg_error_error_info (GOCmdContext *cc, GOErrorInfo *error)
4886 {
4887 gnm_go_error_info_dialog_show (
4888 wbcg_toplevel (WBC_GTK (cc)), error);
4889 }
4890
4891 static void
4892 wbcg_error_error_info_list (GOCmdContext *cc, GSList *errs)
4893 {
4894 gnm_go_error_info_list_dialog_show
4895 (wbcg_toplevel (WBC_GTK (cc)), errs);
4896 }
4897
4898 static void
4899 wbcg_progress_set (GOCmdContext *cc, double val)
4900 {
4901 WBCGtk *wbcg = WBC_GTK (cc);
4902 gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (wbcg->progress_bar), val);
4903 }
4904 static void
4905 wbcg_progress_message_set (GOCmdContext *cc, gchar const *msg)
4906 {
4907 WBCGtk *wbcg = WBC_GTK (cc);
4908 gtk_progress_bar_set_text (GTK_PROGRESS_BAR (wbcg->progress_bar), msg);
4909 }
4910 static void
4911 wbcg_gnm_cmd_context_init (GOCmdContextClass *iface)
4912 {
4913 iface->get_password = wbcg_get_password;
4914 iface->set_sensitive = wbcg_set_sensitive;
4915 iface->error.error = wbcg_error_error;
4916 iface->error.error_info = wbcg_error_error_info;
4917 iface->error.error_info_list = wbcg_error_error_info_list;
4918 iface->progress_set = wbcg_progress_set;
4919 iface->progress_message_set = wbcg_progress_message_set;
4920 }
4921
4922 /*************************************************************************/
4923
4924 static void
4925 wbc_gtk_class_init (GObjectClass *gobject_class)
4926 {
4927 WorkbookControlClass *wbc_class =
4928 GNM_WBC_CLASS (gobject_class);
4929
4930 g_return_if_fail (wbc_class != NULL);
4931
4932 debug_tab_order = gnm_debug_flag ("tab-order");
4933
4934 parent_class = g_type_class_peek_parent (gobject_class);
4935 gobject_class->get_property = wbc_gtk_get_property;
4936 gobject_class->set_property = wbc_gtk_set_property;
4937 gobject_class->finalize = wbc_gtk_finalize;
4938
4939 wbc_class->edit_line_set = wbcg_edit_line_set;
4940 wbc_class->selection_descr_set = wbcg_edit_selection_descr_set;
4941 wbc_class->update_action_sensitivity = wbcg_update_action_sensitivity;
4942
4943 wbc_class->sheet.add = wbcg_sheet_add;
4944 wbc_class->sheet.remove = wbcg_sheet_remove;
4945 wbc_class->sheet.focus = wbcg_sheet_focus;
4946 wbc_class->sheet.remove_all = wbcg_sheet_remove_all;
4947
4948 wbc_class->undo_redo.labels = wbcg_undo_redo_labels;
4949 wbc_class->undo_redo.truncate = wbc_gtk_undo_redo_truncate;
4950 wbc_class->undo_redo.pop = wbc_gtk_undo_redo_pop;
4951 wbc_class->undo_redo.push = wbc_gtk_undo_redo_push;
4952
4953 wbc_class->menu_state.update = wbcg_menu_state_update;
4954
4955 wbc_class->claim_selection = wbcg_claim_selection;
4956 wbc_class->paste_from_selection = wbcg_paste_from_selection;
4957 wbc_class->validation_msg = wbcg_validation_msg;
4958
4959 wbc_class->control_new = wbc_gtk_control_new;
4960 wbc_class->init_state = wbc_gtk_init_state;
4961 wbc_class->style_feedback = wbc_gtk_style_feedback;
4962
4963 g_object_class_install_property (gobject_class,
4964 WBG_GTK_PROP_AUTOSAVE_PROMPT,
4965 g_param_spec_boolean ("autosave-prompt",
4966 P_("Autosave prompt"),
4967 P_("Ask about autosave?"),
4968 FALSE,
4969 GSF_PARAM_STATIC | G_PARAM_READWRITE));
4970 g_object_class_install_property (gobject_class,
4971 WBG_GTK_PROP_AUTOSAVE_TIME,
4972 g_param_spec_int ("autosave-time",
4973 P_("Autosave time in seconds"),
4974 P_("Seconds before autosave"),
4975 0, G_MAXINT, 0,
4976 GSF_PARAM_STATIC | G_PARAM_READWRITE));
4977
4978 wbc_gtk_signals [WBC_GTK_MARKUP_CHANGED] = g_signal_new ("markup-changed",
4979 GNM_WBC_GTK_TYPE,
4980 G_SIGNAL_RUN_LAST,
4981 G_STRUCT_OFFSET (WBCGtkClass, markup_changed),
4982 NULL, NULL,
4983 g_cclosure_marshal_VOID__VOID,
4984 G_TYPE_NONE,
4985 0, G_TYPE_NONE);
4986
4987 gtk_window_set_default_icon_name ("gnumeric");
4988 }
4989
4990 static void
4991 wbc_gtk_init (GObject *obj)
4992 {
4993 WBCGtk *wbcg = (WBCGtk *)obj;
4994 GError *error = NULL;
4995 char *uifile;
4996 unsigned i;
4997 GEnumClass *posclass;
4998 GtkStyleContext *ctxt;
4999
5000 wbcg->gui = gnm_gtk_builder_load ("wbcg.ui", NULL, NULL);
5001 wbcg->cancel_button = GET_GUI_ITEM ("cancel_button");
5002 wbcg->ok_button = GET_GUI_ITEM ("ok_button");
5003 wbcg->func_button = GET_GUI_ITEM ("func_button");
5004 wbcg->progress_bar = GET_GUI_ITEM ("progress_bar");
5005 wbcg->auto_expr_label = GET_GUI_ITEM ("auto_expr_label");
5006 wbcg->status_text = GET_GUI_ITEM ("status_text");
5007 wbcg->tabs_paned = GET_GUI_ITEM ("tabs_paned");
5008 wbcg->status_area = GET_GUI_ITEM ("status_area");
5009 wbcg->notebook_area = GET_GUI_ITEM ("notebook_area");
5010 wbcg->snotebook = GET_GUI_ITEM ("snotebook");
5011 wbcg->selection_descriptor = GET_GUI_ITEM ("selection_descriptor");
5012 wbcg->menu_zone = GET_GUI_ITEM ("menu_zone");
5013 wbcg->toolbar_zones[GTK_POS_TOP] = GET_GUI_ITEM ("toolbar_zone_top");
5014 wbcg->toolbar_zones[GTK_POS_BOTTOM] = NULL;
5015 wbcg->toolbar_zones[GTK_POS_LEFT] = GET_GUI_ITEM ("toolbar_zone_left");
5016 wbcg->toolbar_zones[GTK_POS_RIGHT] = GET_GUI_ITEM ("toolbar_zone_right");
5017 wbcg->updating_ui = FALSE;
5018
5019 posclass = G_ENUM_CLASS (g_type_class_peek (gtk_position_type_get_type ()));
5020 for (i = 0; i < posclass->n_values; i++) {
5021 GEnumValue const *ev = posclass->values + i;
5022 GtkWidget *zone = wbcg->toolbar_zones[ev->value];
5023 GtkStyleContext *ctxt;
5024 if (!zone)
5025 continue;
5026 ctxt = gtk_widget_get_style_context (zone);
5027 gtk_style_context_add_class (ctxt, "toolbarzone");
5028 gtk_style_context_add_class (ctxt, ev->value_nick);
5029 }
5030
5031 wbcg->visibility_widgets = g_hash_table_new_full (g_str_hash,
5032 g_str_equal, (GDestroyNotify)g_free, (GDestroyNotify)g_object_unref);
5033 wbcg->undo_for_fullscreen = NULL;
5034 wbcg->hide_for_fullscreen = NULL;
5035
5036 wbcg->autosave_prompt = FALSE;
5037 wbcg->autosave_time = 0;
5038 wbcg->autosave_timer = 0;
5039
5040 /* We are not in edit mode */
5041 wbcg->editing = FALSE;
5042 wbcg->editing_sheet = NULL;
5043 wbcg->editing_cell = NULL;
5044
5045 wbcg->new_object = NULL;
5046
5047 wbcg->idle_update_style_feedback = 0;
5048
5049 wbcg_set_toplevel (wbcg, GET_GUI_ITEM ("toplevel"));
5050 ctxt = gtk_widget_get_style_context (GTK_WIDGET (wbcg_toplevel (wbcg)));
5051 gtk_style_context_add_class (ctxt, "gnumeric");
5052
5053 g_signal_connect (wbcg_toplevel (wbcg), "window_state_event",
5054 G_CALLBACK (cb_wbcg_window_state_event),
5055 wbcg);
5056
5057 wbc_gtk_init_actions (wbcg);
5058 wbcg->ui = gtk_ui_manager_new ();
5059 g_object_connect (wbcg->ui,
5060 "signal::add_widget", G_CALLBACK (cb_add_menus_toolbars), wbcg,
5061 "signal::connect_proxy", G_CALLBACK (cb_connect_proxy), wbcg,
5062 "signal::disconnect_proxy", G_CALLBACK (cb_disconnect_proxy), wbcg,
5063 "signal::post_activate", G_CALLBACK (cb_post_activate), wbcg,
5064 NULL);
5065 gtk_ui_manager_insert_action_group (wbcg->ui, wbcg->permanent_actions, 0);
5066 gtk_ui_manager_insert_action_group (wbcg->ui, wbcg->actions, 0);
5067 gtk_ui_manager_insert_action_group (wbcg->ui, wbcg->font_actions, 0);
5068 gtk_ui_manager_insert_action_group (wbcg->ui, wbcg->data_only_actions, 0);
5069 gtk_ui_manager_insert_action_group (wbcg->ui, wbcg->semi_permanent_actions, 0);
5070 gtk_window_add_accel_group (wbcg_toplevel (wbcg),
5071 gtk_ui_manager_get_accel_group (wbcg->ui));
5072
5073 if (extra_actions)
5074 gtk_action_group_add_actions (wbcg->actions, extra_actions,
5075 extra_actions_nb, wbcg);
5076
5077 uifile = g_build_filename (gnm_sys_data_dir (),
5078 (uifilename? uifilename: "GNOME_Gnumeric-gtk.xml"), NULL);
5079
5080 if (!gtk_ui_manager_add_ui_from_file (wbcg->ui, uifile, &error)) {
5081 g_message ("building menus failed: %s", error->message);
5082 g_error_free (error);
5083 }
5084 g_free (uifile);
5085
5086 wbcg->custom_uis = g_hash_table_new_full (g_direct_hash, g_direct_equal,
5087 NULL, g_free);
5088
5089 wbcg->file_history.actions = NULL;
5090 wbcg->file_history.merge_id = 0;
5091
5092 wbcg->toolbar.merge_id = gtk_ui_manager_new_merge_id (wbcg->ui);
5093 wbcg->toolbar.actions = gtk_action_group_new ("Toolbars");
5094 gtk_ui_manager_insert_action_group (wbcg->ui, wbcg->toolbar.actions, 0);
5095
5096 wbcg->windows.actions = NULL;
5097 wbcg->windows.merge_id = 0;
5098
5099 wbcg->templates.actions = NULL;
5100 wbcg->templates.merge_id = 0;
5101
5102 gnm_app_foreach_extra_ui ((GFunc) cb_init_extra_ui, wbcg);
5103 g_object_connect ((GObject *) gnm_app_get_app (),
5104 "swapped-object-signal::window-list-changed",
5105 G_CALLBACK (cb_regenerate_window_menu), wbcg,
5106 "object-signal::custom-ui-added",
5107 G_CALLBACK (cb_add_custom_ui), wbcg,
5108 "object-signal::custom-ui-removed",
5109 G_CALLBACK (cb_remove_custom_ui), wbcg,
5110 NULL);
5111
5112 gtk_ui_manager_ensure_update (wbcg->ui);
5113
5114 /* updates the undo/redo menu labels before check_underlines
5115 * to avoid problems like #324692. */
5116 wb_control_undo_redo_labels (GNM_WBC (wbcg), NULL, NULL);
5117 if (GNM_VERSION_MAJOR % 2 != 0 ||
5118 gnm_debug_flag ("underlines")) {
5119 gtk_container_foreach (GTK_CONTAINER (wbcg->menu_zone),
5120 (GtkCallback)check_underlines,
5121 (gpointer)"");
5122 }
5123
5124 wbcg_set_autosave_time (wbcg, gnm_conf_get_core_workbook_autosave_time ());
5125 }
5126
5127 GSF_CLASS_FULL (WBCGtk, wbc_gtk, NULL, NULL, wbc_gtk_class_init, NULL,
5128 wbc_gtk_init, GNM_WBC_TYPE, 0,
5129 GSF_INTERFACE (wbcg_go_plot_data_allocator_init, GOG_TYPE_DATA_ALLOCATOR);
5130 GSF_INTERFACE (wbcg_gnm_cmd_context_init, GO_TYPE_CMD_CONTEXT))
5131
5132 /******************************************************************************/
5133
5134 void
5135 wbc_gtk_markup_changer (WBCGtk *wbcg)
5136 {
5137 g_signal_emit (G_OBJECT (wbcg), wbc_gtk_signals [WBC_GTK_MARKUP_CHANGED], 0);
5138 }
5139
5140 /******************************************************************************/
5141 /**
5142 * wbc_gtk_new:
5143 * @optional_view: (allow-none): #WorkbookView
5144 * @optional_wb: (allow-none) (transfer full): #Workbook
5145 * @optional_screen: (allow-none): #GdkScreen.
5146 * @optional_geometry: (allow-none): string.
5147 *
5148 * Returns: (transfer none): (allow-none): the new #WBCGtk or %NULL.
5149 **/
5150 WBCGtk *
5151 wbc_gtk_new (WorkbookView *optional_view,
5152 Workbook *optional_wb,
5153 GdkScreen *optional_screen,
5154 gchar *optional_geometry)
5155 {
5156 Sheet *sheet;
5157 WorkbookView *wbv;
5158 WBCGtk *wbcg = g_object_new (wbc_gtk_get_type (), NULL);
5159 WorkbookControl *wbc = (WorkbookControl *)wbcg;
5160
5161 wbcg->preferred_geometry = g_strdup (optional_geometry);
5162
5163 wbc_gtk_create_edit_area (wbcg);
5164 wbc_gtk_create_status_area (wbcg);
5165 wbc_gtk_reload_recent_file_menu (wbcg);
5166
5167 g_signal_connect_object (gnm_app_get_app (),
5168 "notify::file-history-list",
5169 G_CALLBACK (wbc_gtk_reload_recent_file_menu), wbcg, G_CONNECT_SWAPPED);
5170
5171 wb_control_set_view (wbc, optional_view, optional_wb);
5172 wbv = wb_control_view (wbc);
5173 sheet = wbv->current_sheet;
5174 if (sheet != NULL) {
5175 wb_control_menu_state_update (wbc, MS_ALL);
5176 wb_control_update_action_sensitivity (wbc);
5177 wb_control_style_feedback (wbc, NULL);
5178 cb_zoom_change (sheet, NULL, wbcg);
5179 }
5180
5181 wbc_gtk_create_notebook_area (wbcg);
5182
5183 wbcg_view_changed (wbcg, NULL, NULL);
5184
5185 if (optional_screen)
5186 gtk_window_set_screen (wbcg_toplevel (wbcg), optional_screen);
5187
5188 /* Postpone showing the GUI, so that we may resize it freely. */
5189 g_idle_add ((GSourceFunc)show_gui, wbcg);
5190
5191 /* Load this later when thing have calmed down. If this does not
5192 trigger by the time the file menu is activated, then the UI is
5193 updated right then -- and that looks sub-optimal because the
5194 "Templates" menu is empty (and thus not shown) until the
5195 update is done. */
5196 wbcg->template_loader_handler =
5197 g_timeout_add (1000, (GSourceFunc)wbc_gtk_load_templates, wbcg);
5198
5199 wb_control_init_state (wbc);
5200 return wbcg;
5201 }
5202
5203 /**
5204 * wbcg_toplevel:
5205 * @wbcg: #WBCGtk
5206 *
5207 * Returns: (transfer none): the toplevel #GtkWindow.
5208 **/
5209 GtkWindow *
5210 wbcg_toplevel (WBCGtk *wbcg)
5211 {
5212 g_return_val_if_fail (GNM_IS_WBC_GTK (wbcg), NULL);
5213 return GTK_WINDOW (wbcg->toplevel);
5214 }
5215
5216 void
5217 wbcg_set_transient (WBCGtk *wbcg, GtkWindow *window)
5218 {
5219 go_gtk_window_set_transient (wbcg_toplevel (wbcg), window);
5220 }
5221
5222 int
5223 wbcg_get_n_scg (WBCGtk const *wbcg)
5224 {
5225 return (GTK_IS_NOTEBOOK (wbcg->snotebook))?
5226 gtk_notebook_get_n_pages (wbcg->snotebook): -1;
5227 }
5228
5229 /**
5230 * wbcg_get_nth_scg:
5231 * @wbcg: #WBCGtk
5232 * @i:
5233 *
5234 * Returns: (transfer none): the scg associated with the @i-th tab in
5235 * @wbcg's notebook.
5236 * NOTE : @i != scg->sv->sheet->index_in_wb
5237 **/
5238 SheetControlGUI *
5239 wbcg_get_nth_scg (WBCGtk *wbcg, int i)
5240 {
5241 SheetControlGUI *scg;
5242 GtkWidget *w;
5243
5244 g_return_val_if_fail (GNM_IS_WBC_GTK (wbcg), NULL);
5245
5246 if (NULL != wbcg->snotebook &&
5247 NULL != (w = gtk_notebook_get_nth_page (wbcg->snotebook, i)) &&
5248 NULL != (scg = get_scg (w)) &&
5249 NULL != scg->grid &&
5250 NULL != scg_sheet (scg) &&
5251 NULL != scg_view (scg))
5252 return scg;
5253
5254 return NULL;
5255 }
5256
5257 #warning merge these and clarfy whether we want the visible scg, or the logical (view) scg
5258 /**
5259 * wbcg_focus_cur_scg:
5260 * @wbcg: The workbook control to operate on.
5261 *
5262 * A utility routine to safely ensure that the keyboard focus
5263 * is attached to the item-grid. This is required when a user
5264 * edits a combo-box or and entry-line which grab focus.
5265 *
5266 * It is called for zoom, font name/size, and accept/cancel for the editline.
5267 * Returns: (transfer none): the sheet.
5268 **/
5269 Sheet *
5270 wbcg_focus_cur_scg (WBCGtk *wbcg)
5271 {
5272 SheetControlGUI *scg;
5273
5274 g_return_val_if_fail (GNM_IS_WBC_GTK (wbcg), NULL);
5275
5276 if (wbcg->snotebook == NULL)
5277 return NULL;
5278
5279 scg = wbcg_get_nth_scg (wbcg,
5280 gtk_notebook_get_current_page (wbcg->snotebook));
5281
5282 g_return_val_if_fail (scg != NULL, NULL);
5283
5284 scg_take_focus (scg);
5285 return scg_sheet (scg);
5286 }
5287
5288 /**
5289 * wbcg_cur_scg:
5290 * @wbcg: #WBCGtk
5291 *
5292 * Returns: (transfer none): the current #ShetControlGUI.
5293 **/
5294 SheetControlGUI *
5295 wbcg_cur_scg (WBCGtk *wbcg)
5296 {
5297 return wbcg_get_scg (wbcg, wbcg_cur_sheet (wbcg));
5298 }
5299
5300 /**
5301 * wbcg_cur_sheet:
5302 * @wbcg: #WBCGtk
5303 *
5304 * Returns: (transfer none): the current #Sheet.
5305 **/
5306 Sheet *
5307 wbcg_cur_sheet (WBCGtk *wbcg)
5308 {
5309 return wb_control_cur_sheet (GNM_WBC (wbcg));
5310 }
5311
5312 PangoFontDescription *
5313 wbcg_get_font_desc (WBCGtk *wbcg)
5314 {
5315 g_return_val_if_fail (GNM_IS_WBC_GTK (wbcg), NULL);
5316
5317 if (!wbcg->font_desc) {
5318 GtkSettings *settings = wbcg_get_gtk_settings (wbcg);
5319 wbcg->font_desc = settings_get_font_desc (settings);
5320 g_signal_connect_object (settings, "notify::gtk-font-name",
5321 G_CALLBACK (cb_desktop_font_changed),
5322 wbcg, 0);
5323 }
5324 return wbcg->font_desc;
5325 }
5326
5327 /**
5328 * wbcg_find_for_workbook:
5329 * @wb: #Workbook
5330 * @candidate: a candidate #WBCGtk
5331 * @pref_screen: the preferred screen.
5332 * @pref_display: the preferred display.
5333 *
5334 * Returns: (transfer none): the found #WBCGtk or %NULL.
5335 **/
5336 WBCGtk *
5337 wbcg_find_for_workbook (Workbook *wb,
5338 WBCGtk *candidate,
5339 GdkScreen *pref_screen,
5340 GdkDisplay *pref_display)
5341 {
5342 gboolean has_screen, has_display;
5343
5344 g_return_val_if_fail (GNM_IS_WORKBOOK (wb), NULL);
5345 g_return_val_if_fail (candidate == NULL || GNM_IS_WBC_GTK (candidate), NULL);
5346
5347 if (candidate && wb_control_get_workbook (GNM_WBC (candidate)) == wb)
5348 return candidate;
5349
5350 if (!pref_screen && candidate)
5351 pref_screen = wbcg_get_screen (candidate);
5352
5353 if (!pref_display && pref_screen)
5354 pref_display = gdk_screen_get_display (pref_screen);
5355
5356 candidate = NULL;
5357 has_screen = FALSE;
5358 has_display = FALSE;
5359 WORKBOOK_FOREACH_CONTROL(wb, wbv, wbc, {
5360 if (GNM_IS_WBC_GTK (wbc)) {
5361 WBCGtk *wbcg = WBC_GTK (wbc);
5362 GdkScreen *screen = wbcg_get_screen (wbcg);
5363 GdkDisplay *display = gdk_screen_get_display (screen);
5364
5365 if (pref_screen == screen && !has_screen) {
5366 has_screen = has_display = TRUE;
5367 candidate = wbcg;
5368 } else if (pref_display == display && !has_display) {
5369 has_display = TRUE;
5370 candidate = wbcg;
5371 } else if (!candidate)
5372 candidate = wbcg;
5373 }
5374 });
5375
5376 return candidate;
5377 }
5378
5379 void
5380 wbcg_focus_current_cell_indicator (WBCGtk const *wbcg)
5381 {
5382 gtk_widget_grab_focus (GTK_WIDGET (wbcg->selection_descriptor));
5383 gtk_editable_select_region (GTK_EDITABLE (wbcg->selection_descriptor), 0, -1);
5384 }
gnumeric mirror