?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Whitespace.
[gnumeric.git] / src / gui-util.c
blobf65a5bae4668ec7b5a8505f3e2970c46bc0adbaa
1 /* vim: set sw=8: -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
2 /*
3 * gnumeric-util.c: Various GUI utility functions.
4 *
5 * Author:
6 * Miguel de Icaza (miguel@gnu.org)
7 */
8
9 #include <gnumeric-config.h>
10 #include <glib/gi18n-lib.h>
11 #include "gnumeric.h"
12 #include "libgnumeric.h"
13 #include "gui-util.h"
14
15 #include "gutils.h"
16 #include "parse-util.h"
17 #include "style.h"
18 #include "style-color.h"
19 #include "value.h"
20 #include "number-match.h"
21 #include "gnm-format.h"
22 #include "application.h"
23 #include "workbook.h"
24 #include "libgnumeric.h"
25 #include "wbc-gtk.h"
26 #include "widgets/gnumeric-expr-entry.h"
27
28 #include <goffice/goffice.h>
29 #include <gtk/gtk.h>
30 #include <atk/atkrelation.h>
31 #include <atk/atkrelationset.h>
32 #include <gdk/gdkkeysyms.h>
33
34 #include <string.h>
35
36 #define ERROR_INFO_MAX_LEVEL 9
37 #define ERROR_INFO_TAG_NAME "errorinfotag%i"
38
39 static void
40 insert_error_info (GtkTextBuffer* text, GOErrorInfo *error, gint level)
41 {
42 gchar *message = (gchar *) go_error_info_peek_message (error);
43 GSList *details_list, *l;
44 GtkTextIter start, last;
45 gchar *tag_name = g_strdup_printf (ERROR_INFO_TAG_NAME,
46 MIN (level, ERROR_INFO_MAX_LEVEL));
47 if (message == NULL)
48 message = g_strdup (_("Multiple errors\n"));
49 else
50 message = g_strdup_printf ("%s\n", message);
51 gtk_text_buffer_get_bounds (text, &start, &last);
52 gtk_text_buffer_insert_with_tags_by_name (text, &last,
53 message, -1,
54 tag_name, NULL);
55 g_free (tag_name);
56 g_free (message);
57 details_list = go_error_info_peek_details (error);
58 for (l = details_list; l != NULL; l = l->next) {
59 GOErrorInfo *detail_error = l->data;
60 insert_error_info (text, detail_error, level + 1);
61 }
62 return;
63 }
64
65 /**
66 * gnumeric_go_error_info_list_dialog_create:
67 * @errs: (element-type GOErrorInfo):
68 *
69 * SHOULD BE IN GOFFICE
70 * Returns: (transfer full): the newly allocated dialog.
71 */
72 static GtkWidget *
73 gnumeric_go_error_info_list_dialog_create (GSList *errs)
74 {
75 GtkWidget *dialog;
76 GtkWidget *scrolled_window;
77 GtkTextView *view;
78 GtkTextBuffer *text;
79 GtkMessageType mtype;
80 gint bf_lim = 1;
81 gint i;
82 GdkScreen *screen;
83 GSList *l, *lf;
84 int severity = 0, this_severity;
85 gboolean message_null = TRUE;
86
87 for (l = errs; l != NULL; l = l->next) {
88 GOErrorInfo *err = l->data;
89 if (go_error_info_peek_message (err)!= NULL)
90 message_null = FALSE;
91 this_severity = go_error_info_peek_severity (err);
92 if (this_severity > severity)
93 severity = this_severity;
94 }
95 lf = g_slist_copy (errs);
96 lf = g_slist_reverse (lf);
97
98 if (message_null)
99 bf_lim++;
100
101 mtype = GTK_MESSAGE_ERROR;
102 if (severity < GO_ERROR)
103 mtype = GTK_MESSAGE_WARNING;
104 dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_DESTROY_WITH_PARENT,
105 mtype, GTK_BUTTONS_CLOSE, " ");
106 screen = gtk_widget_get_screen (dialog);
107 gtk_widget_set_size_request (dialog,
108 gdk_screen_get_width (screen) / 3,
109 gdk_screen_get_width (screen) / 4);
110 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
111 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
112 GTK_POLICY_AUTOMATIC,
113 GTK_POLICY_AUTOMATIC);
114 gtk_scrolled_window_set_shadow_type
115 (GTK_SCROLLED_WINDOW (scrolled_window),
116 GTK_SHADOW_ETCHED_IN);
117 view = GTK_TEXT_VIEW (gtk_text_view_new ());
118 gtk_text_view_set_wrap_mode (view, GTK_WRAP_WORD);
119 gtk_text_view_set_editable (view, FALSE);
120 gtk_text_view_set_cursor_visible (view, FALSE);
121
122 gtk_text_view_set_pixels_below_lines
123 (view, gtk_text_view_get_pixels_inside_wrap (view) + 3);
124 text = gtk_text_view_get_buffer (view);
125 for (i = ERROR_INFO_MAX_LEVEL; i-- > 0;) {
126 gchar *tag_name = g_strdup_printf (ERROR_INFO_TAG_NAME, i);
127 gtk_text_buffer_create_tag
128 (text, tag_name,
129 "left_margin", i * 12,
130 "right_margin", i * 12,
131 "weight", ((i < bf_lim)
132 ? PANGO_WEIGHT_BOLD
133 : PANGO_WEIGHT_NORMAL),
134 NULL);
135 g_free (tag_name);
136 }
137 for (l = lf; l != NULL; l = l->next) {
138 GOErrorInfo *err = l->data;
139 insert_error_info (text, err, 0);
140 }
141 g_slist_free (lf);
142
143 gtk_container_add (GTK_CONTAINER (scrolled_window), GTK_WIDGET (view));
144 gtk_widget_show_all (GTK_WIDGET (scrolled_window));
145 gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), scrolled_window, TRUE, TRUE, 0);
146
147 gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CLOSE);
148 return dialog;
149 }
150
151 /**
152 * gnm_go_error_info_dialog_create:
153 *
154 * SHOULD BE IN GOFFICE
155 * Returns: (transfer full): the newly allocated dialog.
156 */
157 GtkWidget *
158 gnm_go_error_info_dialog_create (GOErrorInfo *error)
159 {
160 GSList *l = g_slist_append (NULL, error);
161 GtkWidget *w = gnumeric_go_error_info_list_dialog_create (l);
162 g_slist_free (l);
163 return w;
164 }
165
166 /**
167 * gnm_go_error_info_dialog_show:
168 *
169 */
170 void
171 gnm_go_error_info_dialog_show (GtkWindow *parent, GOErrorInfo *error)
172 {
173 GtkWidget *dialog = gnm_go_error_info_dialog_create (error);
174 go_gtk_dialog_run (GTK_DIALOG (dialog), parent);
175 }
176
177 /**
178 * gnm_go_error_info_list_dialog_show:
179 * @parent:
180 * @errs: (element-type GOErrorInfo):
181 *
182 */
183 void
184 gnm_go_error_info_list_dialog_show (GtkWindow *parent,
185 GSList *errs)
186 {
187 GtkWidget *dialog = gnumeric_go_error_info_list_dialog_create (errs);
188 go_gtk_dialog_run (GTK_DIALOG (dialog), parent);
189 }
190
191
192 typedef struct {
193 WBCGtk *wbcg;
194 GtkWidget *dialog;
195 char const *key;
196 gboolean freed;
197 } KeyedDialogContext;
198
199 static void
200 cb_free_keyed_dialog_context (KeyedDialogContext *ctxt)
201 {
202 if (ctxt->freed)
203 return;
204 ctxt->freed = TRUE;
205
206 /*
207 * One of these causes a recursive call which will do nothing due to
208 * ->freed.
209 */
210 g_object_set_data (G_OBJECT (ctxt->wbcg), ctxt->key, NULL);
211 g_object_set_data (G_OBJECT (ctxt->dialog), "KeyedDialog", NULL);
212 g_free (ctxt);
213 }
214
215 static void
216 cb_keyed_dialog_destroy (GtkDialog *dialog)
217 {
218 /*
219 * gtk-builder likes to hold refs on objects. That interferes
220 * with the way we handle finalization of dialogs' state.
221 * Trigger this now.
222 */
223 g_object_set_data (G_OBJECT (dialog), "state", NULL);
224 }
225
226 static gint
227 cb_keyed_dialog_keypress (GtkWidget *dialog, GdkEventKey *event,
228 G_GNUC_UNUSED gpointer user)
229 {
230 if (event->keyval == GDK_KEY_Escape) {
231 gtk_widget_destroy (GTK_WIDGET (dialog));
232 return TRUE;
233 }
234 return FALSE;
235 }
236
237 #define SAVE_SIZES_SCREEN_KEY "geometry-hash"
238
239 static void
240 cb_save_sizes (GtkWidget *dialog, const char *key)
241 {
242 GdkRectangle *r;
243 GtkAllocation da;
244 GdkScreen *screen = gtk_widget_get_screen (dialog);
245 GHashTable *h = g_object_get_data (G_OBJECT (screen),
246 SAVE_SIZES_SCREEN_KEY);
247 if (!h) {
248 h = g_hash_table_new_full (g_str_hash, g_str_equal,
249 (GDestroyNotify)g_free,
250 (GDestroyNotify)g_free);
251 /*
252 * We hang this on the screen because pixel sizes make
253 * no sense across screens.
254 *
255 * ANYONE WHO CHANGES THIS CODE TO SAVE THESE SIZES ON EXIT
256 * AND RELOADS THEM ON STARTUP WILL GET TARRED AND FEATHERED.
257 * -- MW, 20071113
258 */
259 g_object_set_data_full (G_OBJECT (screen),
260 SAVE_SIZES_SCREEN_KEY, h,
261 (GDestroyNotify)g_hash_table_destroy);
262 }
263
264 gtk_widget_get_allocation (dialog, &da);
265 r = g_memdup (&da, sizeof (da));
266 gdk_window_get_position (gtk_widget_get_window (dialog), &r->x, &r->y);
267 g_hash_table_replace (h, g_strdup (key), r);
268 }
269
270 void
271 gnm_restore_window_geometry (GtkWindow *dialog, const char *key)
272 {
273 GtkWidget *top = gtk_widget_get_toplevel (GTK_WIDGET (dialog));
274 GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (dialog));
275 GHashTable *h = g_object_get_data (G_OBJECT (screen), SAVE_SIZES_SCREEN_KEY);
276 GdkRectangle *allocation = h ? g_hash_table_lookup (h, key) : NULL;
277
278 if (allocation) {
279 #if 0
280 g_printerr ("Restoring %s to %dx%d at (%d,%d)\n",
281 key, allocation->width, allocation->height,
282 allocation->x, allocation->y);
283 #endif
284 gtk_window_move
285 (GTK_WINDOW (top),
286 allocation->x, allocation->y);
287 gtk_window_set_default_size
288 (GTK_WINDOW (top),
289 allocation->width, allocation->height);
290 }
291
292 g_signal_connect (G_OBJECT (dialog), "unrealize",
293 G_CALLBACK (cb_save_sizes),
294 (gpointer)key);
295 }
296
297 /**
298 * gnm_keyed_dialog:
299 * @wbcg: A WBCGtk
300 * @dialog: A transient window
301 * @key: A key to identify the dialog
302 *
303 * Make dialog a transient child of wbcg, attaching to wbcg object data to
304 * identify the dialog. The object data makes it possible to ensure that
305 * only one dialog of a kind can be displayed for a wbcg. Deallocation of
306 * the object data is managed here.
307 **/
308 void
309 gnm_keyed_dialog (WBCGtk *wbcg, GtkWindow *dialog, char const *key)
310 {
311 KeyedDialogContext *ctxt;
312
313 g_return_if_fail (GNM_IS_WBC_GTK (wbcg));
314 g_return_if_fail (GTK_IS_WINDOW (dialog));
315 g_return_if_fail (key != NULL);
316
317 wbcg_set_transient (wbcg, dialog);
318
319 go_dialog_guess_alternative_button_order (GTK_DIALOG (dialog));
320
321 ctxt = g_new (KeyedDialogContext, 1);
322 ctxt->wbcg = wbcg;
323 ctxt->dialog = GTK_WIDGET (dialog);
324 ctxt->key = key;
325 ctxt->freed = FALSE;
326 g_object_set_data_full (G_OBJECT (wbcg), key, ctxt,
327 (GDestroyNotify)cb_free_keyed_dialog_context);
328 g_object_set_data_full (G_OBJECT (dialog), "KeyedDialog", ctxt,
329 (GDestroyNotify)cb_free_keyed_dialog_context);
330 g_signal_connect (G_OBJECT (dialog), "key_press_event",
331 G_CALLBACK (cb_keyed_dialog_keypress), NULL);
332 g_signal_connect (G_OBJECT (dialog), "destroy",
333 G_CALLBACK (cb_keyed_dialog_destroy), NULL);
334
335 gnm_restore_window_geometry (dialog, key);
336 }
337
338 /**
339 * gnm_dialog_raise_if_exists:
340 * @wbcg: A WBCGtk
341 * @key: A key to identify the dialog
342 *
343 * Raise the dialog identified by key if it is registered on the wbcg.
344 * Returns: (transfer none): TRUE if dialog found, FALSE if not.
345 **/
346 gpointer
347 gnm_dialog_raise_if_exists (WBCGtk *wbcg, char const *key)
348 {
349 KeyedDialogContext *ctxt;
350
351 g_return_val_if_fail (wbcg != NULL, NULL);
352 g_return_val_if_fail (key != NULL, NULL);
353
354 /* Ensure we only pop up one copy per workbook */
355 ctxt = g_object_get_data (G_OBJECT (wbcg), key);
356 if (ctxt && GTK_IS_WINDOW (ctxt->dialog)) {
357 gdk_window_raise (gtk_widget_get_window (ctxt->dialog));
358 return ctxt->dialog;
359 } else
360 return NULL;
361 }
362
363 static gboolean
364 cb_activate_default (GtkWindow *window)
365 {
366 GtkWidget *dw = gtk_window_get_default_widget (window);
367 /*
368 * gtk_window_activate_default has a bad habit of trying
369 * to activate the focus widget.
370 */
371 return dw && gtk_widget_is_sensitive (dw) &&
372 gtk_window_activate_default (window);
373 }
374
375
376 /**
377 * gnm_editable_enters:
378 * @window: dialog to affect.
379 * @editable: Editable to affect.
380 *
381 * Make the "activate" signal of an editable click the default dialog button.
382 *
383 * This is a literal copy of gnome_dialog_editable_enters, but not restricted
384 * to GnomeDialogs.
385 *
386 * Normally if there's an editable widget (such as #GtkEntry) in your
387 * dialog, pressing Enter will activate the editable rather than the
388 * default dialog button. However, in most cases, the user expects to
389 * type something in and then press enter to close the dialog. This
390 * function enables that behavior.
391 *
392 **/
393 void
394 gnm_editable_enters (GtkWindow *window, GtkWidget *w)
395 {
396 g_return_if_fail (GTK_IS_WINDOW(window));
397
398 /* because I really do not feel like changing all the calls to this routine */
399 if (GNM_EXPR_ENTRY_IS (w))
400 w = GTK_WIDGET (gnm_expr_entry_get_entry (GNM_EXPR_ENTRY (w)));
401
402 g_signal_connect_swapped (G_OBJECT (w),
403 "activate",
404 G_CALLBACK (cb_activate_default), window);
405 }
406
407 /**
408 * gnm_gtk_radio_group_get_selected:
409 * @radio_group: (element-type GtkRadioButton): list of radio buttons.
410 *
411 * Returns: the index of the selected radio button starting from list end.
412 **/
413 int
414 gnm_gtk_radio_group_get_selected (GSList *radio_group)
415 {
416 GSList *l;
417 int i, c;
418
419 g_return_val_if_fail (radio_group != NULL, 0);
420
421 c = g_slist_length (radio_group);
422
423 for (i = 0, l = radio_group; l; l = l->next, i++){
424 GtkRadioButton *button = l->data;
425
426 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)))
427 return c - i - 1;
428 }
429
430 return 0;
431 }
432
433
434 int
435 gnm_gui_group_value (gpointer gui, char const * const group[])
436 {
437 int i;
438 for (i = 0; group[i]; i++) {
439 GtkWidget *w = go_gtk_builder_get_widget (gui, group[i]);
440 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)))
441 return i;
442 }
443 return -1;
444 }
445
446 static gboolean
447 cb_delayed_destroy (gpointer w)
448 {
449 gtk_widget_destroy (gtk_widget_get_toplevel (w));
450 gtk_widget_destroy (w);
451 g_object_unref (w);
452 return FALSE;
453 }
454
455 static void
456 kill_popup_menu (GtkWidget *widget, G_GNUC_UNUSED gpointer user)
457 {
458 /* gtk+ currently gets unhappy if we destroy here, see bug 725142 */
459 g_idle_add (cb_delayed_destroy, widget);
460 }
461
462 /**
463 * gnumeric_popup_menu:
464 * @menu: #GtkMenu
465 * @event: #GdkEvent optionally NULL
466 *
467 * Bring up a popup and if @event is non-NULL ensure that the popup is on the
468 * right screen.
469 **/
470 void
471 gnumeric_popup_menu (GtkMenu *menu, GdkEvent *event)
472 {
473 g_return_if_fail (menu != NULL);
474 g_return_if_fail (GTK_IS_MENU (menu));
475
476 if (event)
477 gtk_menu_set_screen (menu, gdk_event_get_screen (event));
478
479 g_object_ref_sink (menu);
480 g_signal_connect (G_OBJECT (menu),
481 "hide",
482 G_CALLBACK (kill_popup_menu), NULL);
483
484 /* Do NOT pass the button used to create the menu.
485 * instead pass 0. Otherwise bringing up a menu with
486 * the right button will disable clicking on the menu with the left.
487 */
488 gtk_menu_popup (menu, NULL, NULL, NULL, NULL, 0,
489 (event
490 ? gdk_event_get_time (event)
491 : gtk_get_current_event_time()));
492 }
493
494 static void
495 gnumeric_tooltip_set_style (GtkWidget *widget)
496 {
497 gtk_style_context_add_class (gtk_widget_get_style_context (widget),
498 GTK_STYLE_CLASS_TOOLTIP);
499 gtk_style_context_add_class (gtk_widget_get_style_context (widget),
500 "pseudo-tooltip");
501 if (GTK_IS_CONTAINER (widget))
502 gtk_container_forall (GTK_CONTAINER (widget),
503 (GtkCallback) (gnumeric_tooltip_set_style),
504 NULL);
505 }
506
507 /**
508 * gnm_convert_to_tooltip:
509 * @ref_widget:
510 * @widget:
511 *
512 * Returns: (transfer none): @widget
513 **/
514 GtkWidget *
515 gnm_convert_to_tooltip (GtkWidget *ref_widget, GtkWidget *widget)
516 {
517 GtkWidget *tip, *frame;
518 GdkScreen *screen = gtk_widget_get_screen (ref_widget);
519
520 tip = gtk_window_new (GTK_WINDOW_POPUP);
521 gtk_window_set_type_hint (GTK_WINDOW (tip),
522 GDK_WINDOW_TYPE_HINT_TOOLTIP);
523 gtk_window_set_resizable (GTK_WINDOW (tip), FALSE);
524 gtk_window_set_gravity (GTK_WINDOW (tip), GDK_GRAVITY_NORTH_WEST);
525 gtk_window_set_screen (GTK_WINDOW (tip), screen);
526 gtk_widget_set_name (tip, "gtk-tooltip");
527
528 frame = gtk_frame_new (NULL);
529 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
530 gtk_widget_show (frame);
531 gtk_container_add (GTK_CONTAINER (frame), widget);
532 gtk_container_add (GTK_CONTAINER (tip), frame);
533
534 gnumeric_tooltip_set_style (tip);
535
536 return widget;
537 }
538
539 /**
540 * gnm_create_tooltip:
541 *
542 * Returns: (transfer full): the newly allocated #GtkWidget.
543 **/
544 GtkWidget *
545 gnm_create_tooltip (GtkWidget *ref_widget)
546 {
547 return gnm_convert_to_tooltip (ref_widget, gtk_label_new (""));
548 }
549
550 void
551 gnm_position_tooltip (GtkWidget *tip, int px, int py, gboolean horizontal)
552 {
553 GtkRequisition req;
554
555 gtk_widget_get_preferred_size (tip, &req, NULL);
556
557 if (horizontal){
558 px -= req.width / 2;
559 py -= req.height + 20;
560 } else {
561 px -= req.width + 20;
562 py -= req.height / 2;
563 }
564
565 if (px < 0)
566 px = 0;
567 if (py < 0)
568 py = 0;
569
570 gtk_window_move (GTK_WINDOW (gtk_widget_get_toplevel (tip)), px, py);
571 }
572
573 /**
574 * gnm_gtk_builder_load:
575 * @cc: #GOCmdContext
576 * @uifile:
577 *
578 * Simple utility to open ui files
579 * Returns: (transfer full): the newly allocated #GtkBuilder.
580 **/
581 GtkBuilder *
582 gnm_gtk_builder_load (char const *uifile, char const *domain, GOCmdContext *cc)
583 {
584 GtkBuilder *gui;
585 char *f;
586
587 if (g_path_is_absolute (uifile)) {
588 f = g_strdup (uifile);
589 } else {
590 f = g_strconcat ("res:gnm:", uifile, NULL);
591 }
592
593 gui = go_gtk_builder_load (f, domain, cc);
594 g_free (f);
595
596 return gui;
597 }
598
599 static void
600 popup_item_activate (GtkWidget *item, gpointer *user_data)
601 {
602 GnmPopupMenuElement const *elem =
603 g_object_get_data (G_OBJECT (item), "descriptor");
604 GnmPopupMenuHandler handler =
605 g_object_get_data (G_OBJECT (item), "handler");
606
607 g_return_if_fail (elem != NULL);
608 g_return_if_fail (handler != NULL);
609
610 handler (elem, user_data);
611 }
612
613 /**
614 * gnm_create_popup_menu:
615 * @elements:
616 * @handler: (scope async):
617 * @user_data: user data to pass to @handler.
618 * @display_filter:
619 * @sensitive_filter:
620 * @event:
621 **/
622 void
623 gnm_create_popup_menu (GnmPopupMenuElement const *elements,
624 GnmPopupMenuHandler handler,
625 gpointer user_data,
626 int display_filter, int sensitive_filter,
627 GdkEvent *event)
628 {
629 char const *trans;
630 GSList *menu_stack = NULL;
631 GtkWidget *menu, *item;
632
633 menu = gtk_menu_new ();
634 for (; NULL != elements->name ; elements++) {
635 char const * const name = elements->name;
636 char const * const pix_name = elements->pixmap;
637
638 item = NULL;
639
640 if (elements->display_filter != 0 &&
641 !(elements->display_filter & display_filter)) {
642 if (elements->allocated_name) {
643 g_free (elements->allocated_name);
644 *(gchar **)(&elements->allocated_name) = NULL;
645 }
646 continue;
647 }
648
649 if (name != NULL && *name != '\0') {
650 if (elements->allocated_name)
651 trans = elements->allocated_name;
652 else
653 trans = _(name);
654 item = gtk_image_menu_item_new_with_mnemonic (trans);
655 if (elements->sensitive_filter != 0 &&
656 (elements->sensitive_filter & sensitive_filter))
657 gtk_widget_set_sensitive (GTK_WIDGET (item), FALSE);
658 if (pix_name != NULL) {
659 GtkWidget *image = gtk_image_new_from_icon_name (pix_name,
660 GTK_ICON_SIZE_MENU);
661 gtk_widget_show (image);
662 gtk_image_menu_item_set_image (
663 GTK_IMAGE_MENU_ITEM (item),
664 image);
665 }
666 if (elements->allocated_name) {
667 g_free (elements->allocated_name);
668 *(gchar **)(&elements->allocated_name) = NULL;
669 }
670 } else if (elements->index >= 0) {
671 /* separator */
672 item = gtk_menu_item_new ();
673 gtk_widget_set_sensitive (item, FALSE);
674 }
675
676 if (elements->index > 0) {
677 g_signal_connect (G_OBJECT (item),
678 "activate",
679 G_CALLBACK (&popup_item_activate), user_data);
680 g_object_set_data (
681 G_OBJECT (item), "descriptor", (gpointer)(elements));
682 g_object_set_data (
683 G_OBJECT (item), "handler", (gpointer)handler);
684 }
685 if (NULL != item) {
686 gtk_widget_show (item);
687 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
688 }
689 if (elements->index < 0) {
690 if (NULL != item) {
691 menu_stack = g_slist_prepend (menu_stack, menu);
692 menu = gtk_menu_new ();
693 gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), menu);
694 } else {
695 menu = menu_stack->data;
696 menu_stack = g_slist_remove (menu_stack, menu);
697 }
698 }
699 }
700 gnumeric_popup_menu (GTK_MENU (menu), event);
701 }
702
703 void
704 gnm_init_help_button (GtkWidget *w, char const *lnk)
705 {
706 go_gtk_help_button_init (w, gnm_sys_data_dir (), "gnumeric", lnk);
707 }
708
709 char *
710 gnm_textbuffer_get_text (GtkTextBuffer *buf)
711 {
712 GtkTextIter start, end;
713
714 g_return_val_if_fail (buf != NULL, NULL);
715
716 gtk_text_buffer_get_start_iter (buf, &start);
717 gtk_text_buffer_get_end_iter (buf, &end);
718 /* We are using slice rather than text so that the tags still match */
719 return gtk_text_buffer_get_slice (buf, &start, &end, FALSE);
720 }
721
722 char *
723 gnm_textview_get_text (GtkTextView *text_view)
724 {
725 return gnm_textbuffer_get_text
726 (gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view)));
727 }
728
729 void
730 gnm_textview_set_text (GtkTextView *text_view, char const *txt)
731 {
732 gtk_text_buffer_set_text (
733 gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view)),
734 txt, -1);
735 }
736
737 void
738 gnm_load_pango_attributes_into_buffer (PangoAttrList *markup, GtkTextBuffer *buffer, gchar const *str)
739 {
740 gchar *str_retrieved = NULL;
741
742 if (str == NULL) {
743 GtkTextIter start, end;
744 gtk_text_buffer_get_start_iter (buffer, &start);
745 gtk_text_buffer_get_end_iter (buffer, &end);
746 str = str_retrieved = gtk_text_buffer_get_slice
747 (buffer, &start, &end, TRUE);
748 }
749
750 go_load_pango_attributes_into_buffer (markup, buffer, str);
751
752 g_free (str_retrieved);
753 }
754
755 #define gnmstoretexttagattrinpangoint(nameset, name, gnm_pango_attr_new) \
756 if (gnm_object_get_bool (tag, nameset)) { \
757 int value; \
758 g_object_get (G_OBJECT (tag), name, &value, NULL); \
759 attr = gnm_pango_attr_new (value); \
760 attr->start_index = x; \
761 attr->end_index = y; \
762 pango_attr_list_change (list, attr); \
763 }
764
765
766 static void
767 gnm_store_text_tag_attr_in_pango (PangoAttrList *list, GtkTextTag *tag, GtkTextIter *start, gchar const *text)
768 {
769 GtkTextIter end = *start;
770 gint x, y;
771 PangoAttribute * attr;
772
773 gtk_text_iter_forward_to_tag_toggle (&end, tag);
774 x = g_utf8_offset_to_pointer (text, gtk_text_iter_get_offset (start)) - text;
775 y = g_utf8_offset_to_pointer (text, gtk_text_iter_get_offset (&end)) - text;
776
777 if (gnm_object_get_bool (tag, "foreground-set")) {
778 GdkRGBA *color = NULL;
779 g_object_get (G_OBJECT (tag), "foreground-rgba", &color, NULL);
780 if (color) {
781 /* dividing 0 to 1 into 65536 equal length intervals */
782 attr = pango_attr_foreground_new
783 ((int)(CLAMP (color->red * 65536, 0., 65535.)),
784 (int)(CLAMP (color->green * 65536, 0., 65535.)),
785 (int)(CLAMP (color->blue * 65536, 0., 65535.)));
786 gdk_rgba_free (color);
787 attr->start_index = x;
788 attr->end_index = y;
789 pango_attr_list_change (list, attr);
790 }
791 }
792
793 gnmstoretexttagattrinpangoint ("style-set", "style", pango_attr_style_new)
794 gnmstoretexttagattrinpangoint ("weight-set", "weight", pango_attr_weight_new)
795 gnmstoretexttagattrinpangoint ("strikethrough-set", "strikethrough", pango_attr_strikethrough_new)
796 gnmstoretexttagattrinpangoint ("underline-set", "underline", pango_attr_underline_new)
797 gnmstoretexttagattrinpangoint ("rise-set", "rise", pango_attr_rise_new)
798 }
799
800 #undef gnmstoretexttagattrinpangoint
801
802 PangoAttrList *
803 gnm_get_pango_attributes_from_buffer (GtkTextBuffer *buffer)
804 {
805 PangoAttrList *list = pango_attr_list_new ();
806 GtkTextIter start;
807 gchar *text = gnm_textbuffer_get_text (buffer);
808
809 gtk_text_buffer_get_start_iter (buffer, &start);
810
811 while (!gtk_text_iter_is_end (&start)) {
812 if (gtk_text_iter_begins_tag (&start, NULL)) {
813 GSList *ptr, *l = gtk_text_iter_get_toggled_tags (&start, TRUE);
814 for (ptr = l; ptr; ptr = ptr->next)
815 gnm_store_text_tag_attr_in_pango (list, ptr->data, &start, text);
816 }
817 gtk_text_iter_forward_to_tag_toggle (&start, NULL);
818 }
819
820 g_free (text);
821
822 return list;
823 }
824
825 void
826 focus_on_entry (GtkEntry *entry)
827 {
828 if (entry == NULL)
829 return;
830 gtk_widget_grab_focus (GTK_WIDGET(entry));
831 gtk_editable_set_position (GTK_EDITABLE (entry), 0);
832 gtk_editable_select_region (GTK_EDITABLE (entry), 0,
833 gtk_entry_get_text_length (entry));
834 }
835
836 gboolean
837 entry_to_float_with_format_default (GtkEntry *entry, gnm_float *the_float,
838 gboolean update,
839 GOFormat const *format, gnm_float num)
840 {
841 char const *text = gtk_entry_get_text (entry);
842 gboolean need_default = (text == NULL);
843
844 if (!need_default) {
845 char *new_text = g_strdup (text);
846 need_default = (0 == strlen (g_strstrip(new_text)));
847 g_free (new_text);
848 }
849
850 if (need_default && !update) {
851 *the_float = num;
852 return FALSE;
853 }
854
855 if (need_default)
856 float_to_entry (entry, num);
857
858 return entry_to_float_with_format (entry, the_float, update, format);
859 }
860
861 gboolean
862 entry_to_float_with_format (GtkEntry *entry, gnm_float *the_float,
863 gboolean update, GOFormat const *format)
864 {
865 GnmValue *value = format_match_number (gtk_entry_get_text (entry), format, NULL);
866
867 *the_float = 0.0;
868 if (!value)
869 return TRUE;
870
871 *the_float = value_get_as_float (value);
872 if (update) {
873 char *tmp = format_value (format, value, 16, NULL);
874 gtk_entry_set_text (entry, tmp);
875 g_free (tmp);
876 }
877
878 value_release (value);
879 return FALSE;
880 }
881
882 /**
883 * entry_to_int:
884 * @entry:
885 * @the_int:
886 * @update:
887 *
888 * Retrieve an int from an entry field parsing all reasonable formats
889 *
890 **/
891 gboolean
892 entry_to_int (GtkEntry *entry, gint *the_int, gboolean update)
893 {
894 GnmValue *value = format_match_number (gtk_entry_get_text (entry), NULL, NULL);
895 gnm_float f;
896
897 *the_int = 0;
898 if (!value)
899 return TRUE;
900
901 f = value_get_as_float (value);
902 if (f < INT_MIN || f > INT_MAX || f != (*the_int = (int)f)) {
903 value_release (value);
904 return TRUE;
905 }
906
907 if (update) {
908 char *tmp = format_value (NULL, value, 16, NULL);
909 gtk_entry_set_text (entry, tmp);
910 g_free (tmp);
911 }
912
913 value_release (value);
914 return FALSE;
915 }
916
917 /**
918 * float_to_entry:
919 * @entry:
920 * @the_float:
921 *
922 **/
923 void
924 float_to_entry (GtkEntry *entry, gnm_float the_float)
925 {
926 GnmValue *val = value_new_float (the_float);
927 char *text = format_value (NULL, val, 16, NULL);
928 value_release(val);
929 if (text != NULL) {
930 gtk_entry_set_text (entry, text);
931 g_free (text);
932 }
933 }
934
935 /**
936 * int_to_entry:
937 * @entry:
938 * @the_int:
939 *
940 *
941 **/
942 void
943 int_to_entry (GtkEntry *entry, gint the_int)
944 {
945 GnmValue *val = value_new_int (the_int);
946 char *text = format_value (NULL, val, 16, NULL);
947 value_release(val);
948 if (text != NULL) {
949 gtk_entry_set_text (entry, text);
950 g_free (text);
951 }
952 }
953
954 static void
955 cb_focus_to_entry (GtkWidget *button, GtkWidget *entry)
956 {
957 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)))
958 gtk_widget_grab_focus (entry);
959 }
960
961 static gboolean
962 cb_activate_button (GtkWidget *button)
963 {
964 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
965 return FALSE;
966 }
967
968 void
969 gnm_link_button_and_entry (GtkWidget *button, GtkWidget *entry)
970 {
971 g_signal_connect (G_OBJECT (button),
972 "clicked", G_CALLBACK (cb_focus_to_entry),
973 entry);
974 g_signal_connect_swapped (G_OBJECT (entry),
975 "focus_in_event",
976 G_CALLBACK (cb_activate_button),
977 button);
978 }
979
980 /* ------------------------------------------------------------------------- */
981
982 void
983 gnm_widget_set_cursor (GtkWidget *w, GdkCursor *cursor)
984 {
985 gdk_window_set_cursor (gtk_widget_get_window (w), cursor);
986 }
987
988 void
989 gnm_widget_set_cursor_type (GtkWidget *w, GdkCursorType ct)
990 {
991 GdkDisplay *display = gtk_widget_get_display (w);
992 GdkCursor *cursor = gdk_cursor_new_for_display (display, ct);
993 gnm_widget_set_cursor (w, cursor);
994 g_object_unref (cursor);
995 }
996
997 /* ------------------------------------------------------------------------- */
998
999 /**
1000 * gnm_message_dialog_create:
1001 *
1002 * A convenience fonction to build HIG compliant message dialogs.
1003 *
1004 * parent : transient parent, or NULL for none.
1005 * flags
1006 * type : type of dialog
1007 * primary_message : message displayed in bold
1008 * secondary_message : message displayed below
1009 *
1010 * Returns: (transfer full): a GtkDialog, without buttons.
1011 **/
1012
1013 GtkWidget *
1014 gnm_message_dialog_create (GtkWindow * parent,
1015 GtkDialogFlags flags,
1016 GtkMessageType type,
1017 gchar const * primary_message,
1018 gchar const * secondary_message)
1019 {
1020 GtkWidget * dialog;
1021 GtkWidget * label;
1022 GtkWidget * hbox;
1023 gchar *message;
1024 const gchar *icon_name;
1025 GtkWidget *image;
1026 const char *title;
1027
1028 dialog = gtk_dialog_new_with_buttons ("", parent, flags, NULL, NULL);
1029
1030 switch (type) {
1031 default:
1032 g_warning ("Unknown GtkMessageType %d", type);
1033 case GTK_MESSAGE_INFO:
1034 icon_name = "dialog-information";
1035 title = _("Information");
1036 break;
1037
1038 case GTK_MESSAGE_QUESTION:
1039 icon_name = "dialog-question";
1040 title = _("Question");
1041 break;
1042
1043 case GTK_MESSAGE_WARNING:
1044 icon_name = "dialog-warning";
1045 title = _("Warning");
1046 break;
1047
1048 case GTK_MESSAGE_ERROR:
1049 icon_name = "dialog-error";
1050 title = _("Error");
1051 break;
1052 }
1053
1054 image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_DIALOG);
1055 gtk_window_set_title (GTK_WINDOW (dialog), title);
1056
1057 if (primary_message) {
1058 if (secondary_message) {
1059 message = g_strdup_printf ("<b>%s</b>\n\n%s",
1060 primary_message,
1061 secondary_message);
1062 } else {
1063 message = g_strdup_printf ("<b>%s</b>",
1064 primary_message);
1065 }
1066 } else {
1067 message = g_strdup_printf ("%s", secondary_message);
1068 }
1069 label = gtk_label_new (message);
1070 g_free (message);
1071
1072 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
1073 gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, TRUE, 0);
1074 gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
1075 gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), hbox, TRUE, TRUE, 0);
1076
1077 gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
1078 gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
1079 gtk_misc_set_alignment (GTK_MISC (label), 0.0 , 0.0);
1080 gtk_box_set_spacing (GTK_BOX (hbox), 12);
1081 gtk_container_set_border_width (GTK_CONTAINER (hbox), 6);
1082 gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), 12);
1083 gtk_container_set_border_width (GTK_CONTAINER (dialog), 6);
1084 gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
1085 gtk_widget_show_all (GTK_WIDGET (gtk_dialog_get_content_area (GTK_DIALOG (dialog))));
1086
1087 return dialog;
1088 }
1089
1090 typedef struct {
1091 GPtrArray *objects_signals;
1092 } GnmDialogDestroySignals;
1093
1094 static void
1095 cb_gnm_dialog_setup_destroy_handlers (G_GNUC_UNUSED GtkWidget *widget,
1096 GnmDialogDestroySignals *dd)
1097 {
1098 GPtrArray *os = dd->objects_signals;
1099 int i;
1100
1101 for (i = 0; i < (int)os->len; i += 2) {
1102 GObject *obj = g_ptr_array_index (os, i);
1103 guint s = GPOINTER_TO_UINT (g_ptr_array_index (os, i + 1));
1104 g_signal_handler_disconnect (obj, s);
1105 }
1106
1107 g_ptr_array_free (os, TRUE);
1108 memset (dd, 0, sizeof (*dd));
1109 g_free (dd);
1110 }
1111
1112 void
1113 gnm_dialog_setup_destroy_handlers (GtkDialog *dialog,
1114 WBCGtk *wbcg,
1115 GnmDialogDestroyOptions what)
1116 {
1117 GnmDialogDestroySignals *dd = g_new (GnmDialogDestroySignals, 1);
1118 Workbook *wb = wb_control_get_workbook (GNM_WBC (wbcg));
1119 Sheet *sheet = wb_control_cur_sheet (GNM_WBC (wbcg));
1120 int N = workbook_sheet_count (wb), i;
1121 GPtrArray *os = g_ptr_array_new ();
1122
1123 dd->objects_signals = os;
1124
1125 /* FIXME: Properly implement CURRENT_SHEET_REMOVED. */
1126 if (what & GNM_DIALOG_DESTROY_CURRENT_SHEET_REMOVED)
1127 what |= GNM_DIALOG_DESTROY_SHEET_REMOVED;
1128
1129 if (what & GNM_DIALOG_DESTROY_SHEET_REMOVED) {
1130 guint s = g_signal_connect_swapped
1131 (G_OBJECT (wb),
1132 "sheet_deleted",
1133 G_CALLBACK (gtk_widget_destroy),
1134 dialog);
1135 g_ptr_array_add (os, wb);
1136 g_ptr_array_add (os, GUINT_TO_POINTER (s));
1137 }
1138
1139 if (what & GNM_DIALOG_DESTROY_SHEET_ADDED) {
1140 guint s = g_signal_connect_swapped
1141 (G_OBJECT (wb),
1142 "sheet_added",
1143 G_CALLBACK (gtk_widget_destroy),
1144 dialog);
1145 g_ptr_array_add (os, wb);
1146 g_ptr_array_add (os, GUINT_TO_POINTER (s));
1147 }
1148
1149 if (what & GNM_DIALOG_DESTROY_SHEETS_REORDERED) {
1150 guint s = g_signal_connect_swapped
1151 (G_OBJECT (wb),
1152 "sheet_order_changed",
1153 G_CALLBACK (gtk_widget_destroy),
1154 dialog);
1155 g_ptr_array_add (os, wb);
1156 g_ptr_array_add (os, GUINT_TO_POINTER (s));
1157 }
1158
1159 for (i = 0; i < N; i++) {
1160 Sheet *this_sheet = workbook_sheet_by_index (wb, i);
1161 gboolean current = (sheet == this_sheet);
1162
1163 if ((what & GNM_DIALOG_DESTROY_SHEET_RENAMED) ||
1164 (current && (what & GNM_DIALOG_DESTROY_CURRENT_SHEET_RENAMED))) {
1165 guint s = g_signal_connect_swapped
1166 (G_OBJECT (this_sheet),
1167 "notify::name",
1168 G_CALLBACK (gtk_widget_destroy),
1169 dialog);
1170 g_ptr_array_add (os, this_sheet);
1171 g_ptr_array_add (os, GUINT_TO_POINTER (s));
1172 }
1173 }
1174
1175 g_signal_connect (G_OBJECT (dialog),
1176 "destroy",
1177 G_CALLBACK (cb_gnm_dialog_setup_destroy_handlers),
1178 dd);
1179 }
1180
1181
1182 void
1183 gnm_canvas_get_position (GocCanvas *canvas, int *x, int *y, gint64 px, gint64 py)
1184 {
1185 GtkWidget *cw = GTK_WIDGET (canvas);
1186 GdkWindow *cbw = gtk_layout_get_bin_window (GTK_LAYOUT (cw));
1187 int wx, wy;
1188
1189 gdk_window_get_origin (cbw, &wx, &wy);
1190
1191 /* we don't need to multiply px and py by the canvas pixels_per_unit
1192 * field since all the callers already do that */
1193 px -= canvas->scroll_x1 * canvas->pixels_per_unit;
1194 py -= canvas->scroll_y1 * canvas->pixels_per_unit;
1195 /* let's take care of RTL sheets */
1196 if (canvas->direction == GOC_DIRECTION_RTL)
1197 px = goc_canvas_get_width (canvas) - px;
1198
1199 *x = px + wx;
1200 *y = py + wy;
1201 }
1202
1203 /*
1204 * Get the gdk position for canvas coordinates (x,y). This is suitable
1205 * for tooltip windows.
1206 *
1207 * It is possible that this does not work right for very large coordinates
1208 * prior to gtk+ 2.18. See the code and comments in gnm_canvas_get_position.
1209 */
1210 void
1211 gnm_canvas_get_screen_position (GocCanvas *canvas,
1212 double x, double y,
1213 int *ix, int *iy)
1214 {
1215 GdkWindow *cbw = gtk_layout_get_bin_window (GTK_LAYOUT (canvas));
1216 int wx, wy;
1217
1218 gdk_window_get_origin (cbw, &wx, &wy);
1219 goc_canvas_c2w (canvas, x, y, ix, iy);
1220 (*ix) += wx;
1221 (*iy) += wy;
1222 }
1223
1224
1225 gboolean
1226 gnm_check_for_plugins_missing (char const **ids, GtkWindow *parent)
1227 {
1228 for (; *ids != NULL; ids++) {
1229 GOPlugin *pi = go_plugins_get_plugin_by_id (*ids);
1230 if (pi == NULL) {
1231 GOErrorInfo *error;
1232 error = go_error_info_new_printf
1233 (_("The plugin with id %s is required "
1234 "but cannot be found."), *ids);
1235 gnm_go_error_info_dialog_show (parent,
1236 error);
1237 return TRUE;
1238 } else if (!go_plugin_is_active (pi)) {
1239 GOErrorInfo *error;
1240 error = go_error_info_new_printf
1241 (_("The %s plugin is required "
1242 "but is not loaded."),
1243 go_plugin_get_name (pi));
1244 gnm_go_error_info_dialog_show (parent,
1245 error);
1246 return TRUE;
1247 }
1248 }
1249 return FALSE;
1250 }
1251
1252
1253 void
1254 gnm_cell_renderer_text_copy_background_to_cairo (GtkCellRendererText *crt,
1255 cairo_t *cr)
1256 {
1257 GdkRGBA *c = NULL;
1258 g_object_get (crt, "background-rgba", &c, NULL);
1259 gdk_cairo_set_source_rgba (cr, c);
1260 gdk_rgba_free (c);
1261 }
1262
1263 int
1264 gnm_widget_measure_string (GtkWidget *w, const char *s)
1265 {
1266 GtkStyleContext *ctxt;
1267 int len;
1268 PangoFontDescription *desc;
1269 GtkStateFlags state = GTK_STATE_FLAG_NORMAL;
1270
1271 ctxt = gtk_widget_get_style_context (w);
1272
1273 // As-of gtk+ 3.20 we have to set the context state to the state
1274 // we are querying for. This ought to work before gtk+ 3.20 too.
1275 gtk_style_context_save (ctxt);
1276 gtk_style_context_set_state (ctxt, state);
1277 gtk_style_context_get (ctxt, state, "font", &desc, NULL);
1278 gtk_style_context_restore (ctxt);
1279
1280 len = go_pango_measure_string
1281 (gtk_widget_get_pango_context (w), desc, s);
1282
1283 pango_font_description_free (desc);
1284
1285 return len;
1286 }
1287
1288 static const char *
1289 gnm_ag_translate (const char *s, const char *ctxt)
1290 {
1291 return ctxt
1292 ? g_dpgettext2 (NULL, ctxt, s)
1293 : _(s);
1294 }
1295
1296 void
1297 gnm_action_group_add_actions (GtkActionGroup *group,
1298 GnmActionEntry const *actions, size_t n,
1299 gpointer user)
1300 {
1301 unsigned i;
1302
1303 for (i = 0; i < n; i++) {
1304 GnmActionEntry const *entry = actions + i;
1305 const char *name = entry->name;
1306 const char *label =
1307 gnm_ag_translate (entry->label, entry->label_context);
1308 const char *tip =
1309 gnm_ag_translate (entry->tooltip, NULL);
1310 GtkAction *a;
1311
1312 if (entry->toggle) {
1313 GtkToggleAction *ta =
1314 gtk_toggle_action_new (name, label, tip, NULL);
1315 gtk_toggle_action_set_active (ta, entry->is_active);
1316 a = GTK_ACTION (ta);
1317 } else {
1318 a = gtk_action_new (name, label, tip, NULL);
1319 }
1320
1321 g_object_set (a, "icon-name", entry->icon, NULL);
1322
1323 if (entry->callback) {
1324 GClosure *closure =
1325 g_cclosure_new (entry->callback, user, NULL);
1326 g_signal_connect_closure (a, "activate", closure,
1327 FALSE);
1328 }
1329
1330 gtk_action_group_add_action_with_accel (group,
1331 a,
1332 entry->accelerator);
1333 g_object_unref (a);
1334 }
1335 }
1336
1337 void
1338 gnm_action_group_add_action (GtkActionGroup *group, GtkAction *act)
1339 {
1340 /*
1341 * See the docs for gtk_action_group_add_action as to why we don't
1342 * call just that.
1343 */
1344 gtk_action_group_add_action_with_accel (group, act, NULL);
1345 }
1346
1347 void
1348 gnm_style_context_get_color (GtkStyleContext *context,
1349 GtkStateFlags state,
1350 GdkRGBA *color)
1351 {
1352 // As-of gtk+ 3.20 we have to set the context state to the state
1353 // we are querying for. This ought to work before gtk+ 3.20 too.
1354 gtk_style_context_save (context);
1355 gtk_style_context_set_state (context, state);
1356 gtk_style_context_get_color (context,
1357 gtk_style_context_get_state (context),
1358 color);
1359 gtk_style_context_restore (context);
1360 }
1361
1362 // ----------------------------------------------------------------------------
gnumeric mirror