1 /* Functions for creating and updating GTK widgets.
3 Copyright (C) 2003-2014 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
30 #include "blockinput.h"
31 #include "syssignal.h"
34 #include "termhooks.h"
40 #include <gdk/gdkkeysyms.h>
41 #include "xsettings.h"
44 #include <X11/Xft/Xft.h>
49 #include "emacsgtkfixed.h"
52 #define FRAME_TOTAL_PIXEL_HEIGHT(f) \
53 (FRAME_PIXEL_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f))
55 #define FRAME_TOTAL_PIXEL_WIDTH(f) \
56 (FRAME_PIXEL_WIDTH (f) + FRAME_TOOLBAR_WIDTH (f))
58 #ifndef HAVE_GTK_WIDGET_SET_HAS_WINDOW
59 #define gtk_widget_set_has_window(w, b) \
60 (gtk_fixed_set_has_window (GTK_FIXED (w), b))
62 #ifndef HAVE_GTK_DIALOG_GET_ACTION_AREA
63 #define gtk_dialog_get_action_area(w) ((w)->action_area)
64 #define gtk_dialog_get_content_area(w) ((w)->vbox)
66 #ifndef HAVE_GTK_WIDGET_GET_SENSITIVE
67 #define gtk_widget_get_sensitive(w) (GTK_WIDGET_SENSITIVE (w))
69 #ifndef HAVE_GTK_ADJUSTMENT_GET_PAGE_SIZE
70 #define gtk_adjustment_set_page_size(w, s) ((w)->page_size = (s))
71 #define gtk_adjustment_set_page_increment(w, s) ((w)->page_increment = (s))
72 #define gtk_adjustment_get_step_increment(w) ((w)->step_increment)
73 #define gtk_adjustment_set_step_increment(w, s) ((w)->step_increment = (s))
75 #if GTK_CHECK_VERSION (2, 12, 0)
76 #define remove_submenu(w) gtk_menu_item_set_submenu ((w), NULL)
78 #define remove_submenu(w) gtk_menu_item_remove_submenu ((w))
82 #if GTK_CHECK_VERSION (3, 2, 0)
83 #define USE_NEW_GTK_FONT_CHOOSER 1
85 #define USE_NEW_GTK_FONT_CHOOSER 0
86 #define gtk_font_chooser_dialog_new(x, y) \
87 gtk_font_selection_dialog_new (x)
88 #undef GTK_FONT_CHOOSER
89 #define GTK_FONT_CHOOSER(x) GTK_FONT_SELECTION_DIALOG (x)
90 #define gtk_font_chooser_set_font(x, y) \
91 gtk_font_selection_dialog_set_font_name (x, y)
93 #endif /* HAVE_FREETYPE */
96 #ifdef USE_GTK_TOOLTIP
97 #define gdk_window_get_screen(w) gdk_drawable_get_screen (w)
99 #define gdk_window_get_geometry(w, a, b, c, d) \
100 gdk_window_get_geometry (w, a, b, c, d, 0)
101 #define gdk_x11_window_lookup_for_display(d, w) \
102 gdk_xid_table_lookup_for_display (d, w)
103 #define gtk_box_new(ori, spacing) \
104 ((ori) == GTK_ORIENTATION_HORIZONTAL \
105 ? gtk_hbox_new (FALSE, (spacing)) : gtk_vbox_new (FALSE, (spacing)))
106 #define gtk_scrollbar_new(ori, spacing) \
107 ((ori) == GTK_ORIENTATION_HORIZONTAL \
108 ? gtk_hscrollbar_new ((spacing)) : gtk_vscrollbar_new ((spacing)))
110 #define GDK_KEY_g GDK_g
112 #endif /* HAVE_GTK3 */
114 #define XG_BIN_CHILD(x) gtk_bin_get_child (GTK_BIN (x))
116 static void update_theme_scrollbar_width (void);
118 #define TB_INFO_KEY "xg_frame_tb_info"
119 struct xg_frame_tb_info
121 Lisp_Object last_tool_bar
;
124 int hmargin
, vmargin
;
125 GtkTextDirection dir
;
129 /***********************************************************************
130 Display handling functions
131 ***********************************************************************/
133 /* Keep track of the default display, or NULL if there is none. Emacs
134 may close all its displays. */
136 static GdkDisplay
*gdpy_def
;
138 /* When the GTK widget W is to be created on a display for F that
139 is not the default display, set the display for W.
140 W can be a GtkMenu or a GtkWindow widget. */
143 xg_set_screen (GtkWidget
*w
, struct frame
*f
)
145 if (FRAME_X_DISPLAY (f
) != DEFAULT_GDK_DISPLAY ())
147 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
148 GdkScreen
*gscreen
= gdk_display_get_default_screen (gdpy
);
151 gtk_menu_set_screen (GTK_MENU (w
), gscreen
);
153 gtk_window_set_screen (GTK_WINDOW (w
), gscreen
);
158 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
159 *DPY is set to NULL if the display can't be opened.
161 Returns non-zero if display could be opened, zero if display could not
162 be opened, and less than zero if the GTK version doesn't support
163 multiple displays. */
166 xg_display_open (char *display_name
, Display
**dpy
)
170 gdpy
= gdk_display_open (display_name
);
171 if (!gdpy_def
&& gdpy
)
174 gdk_display_manager_set_default_display (gdk_display_manager_get (),
178 *dpy
= gdpy
? GDK_DISPLAY_XDISPLAY (gdpy
) : NULL
;
182 /* Close display DPY. */
185 xg_display_close (Display
*dpy
)
187 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
189 /* If this is the default display, try to change it before closing.
190 If there is no other display to use, gdpy_def is set to NULL, and
191 the next call to xg_display_open resets the default display. */
192 if (gdk_display_get_default () == gdpy
)
194 struct x_display_info
*dpyinfo
;
195 GdkDisplay
*gdpy_new
= NULL
;
197 /* Find another display. */
198 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
199 if (dpyinfo
->display
!= dpy
)
201 gdpy_new
= gdk_x11_lookup_xdisplay (dpyinfo
->display
);
202 gdk_display_manager_set_default_display (gdk_display_manager_get (),
209 #if GTK_CHECK_VERSION (2, 0, 0) && ! GTK_CHECK_VERSION (2, 10, 0)
210 /* GTK 2.2-2.8 has a bug that makes gdk_display_close crash (bug
211 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way we
212 can continue running, but there will be memory leaks. */
213 g_object_run_dispose (G_OBJECT (gdpy
));
215 /* This seems to be fixed in GTK 2.10. */
216 gdk_display_close (gdpy
);
221 /***********************************************************************
223 ***********************************************************************/
224 /* The next two variables and functions are taken from lwlib. */
225 static widget_value
*widget_value_free_list
;
226 static int malloc_cpt
;
228 /* Allocate a widget_value structure, either by taking one from the
229 widget_value_free_list or by malloc:ing a new one.
231 Return a pointer to the allocated structure. */
234 malloc_widget_value (void)
237 if (widget_value_free_list
)
239 wv
= widget_value_free_list
;
240 widget_value_free_list
= wv
->free_list
;
245 wv
= xmalloc (sizeof *wv
);
248 memset (wv
, 0, sizeof (widget_value
));
252 /* This is analogous to free. It frees only what was allocated
253 by malloc_widget_value, and no substructures. */
256 free_widget_value (widget_value
*wv
)
263 /* When the number of already allocated cells is too big,
270 wv
->free_list
= widget_value_free_list
;
271 widget_value_free_list
= wv
;
276 /* Create and return the cursor to be used for popup menus and
277 scroll bars on display DPY. */
280 xg_create_default_cursor (Display
*dpy
)
282 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
283 return gdk_cursor_new_for_display (gdpy
, GDK_LEFT_PTR
);
287 xg_get_pixbuf_from_pixmap (struct frame
*f
, Pixmap pix
)
292 unsigned int width
, height
, uunused
;
295 XGetGeometry (FRAME_X_DISPLAY (f
), pix
, &wunused
, &iunused
, &iunused
,
296 &width
, &height
, &uunused
, &uunused
);
298 xim
= XGetImage (FRAME_X_DISPLAY (f
), pix
, 0, 0, width
, height
,
302 tmp_buf
= gdk_pixbuf_new_from_data ((guchar
*) xim
->data
,
315 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
318 xg_get_pixbuf_from_pix_and_mask (struct frame
*f
,
323 GdkPixbuf
*icon_buf
, *tmp_buf
;
325 tmp_buf
= xg_get_pixbuf_from_pixmap (f
, pix
);
326 icon_buf
= gdk_pixbuf_add_alpha (tmp_buf
, FALSE
, 0, 0, 0);
327 g_object_unref (G_OBJECT (tmp_buf
));
329 width
= gdk_pixbuf_get_width (icon_buf
);
330 height
= gdk_pixbuf_get_height (icon_buf
);
334 GdkPixbuf
*mask_buf
= xg_get_pixbuf_from_pixmap (f
, mask
);
335 guchar
*pixels
= gdk_pixbuf_get_pixels (icon_buf
);
336 guchar
*mask_pixels
= gdk_pixbuf_get_pixels (mask_buf
);
337 int rowstride
= gdk_pixbuf_get_rowstride (icon_buf
);
338 int mask_rowstride
= gdk_pixbuf_get_rowstride (mask_buf
);
341 for (y
= 0; y
< height
; ++y
)
343 guchar
*iconptr
, *maskptr
;
346 iconptr
= pixels
+ y
* rowstride
;
347 maskptr
= mask_pixels
+ y
* mask_rowstride
;
349 for (x
= 0; x
< width
; ++x
)
351 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
352 just R is sufficient. */
354 iconptr
[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
356 iconptr
+= rowstride
/width
;
357 maskptr
+= mask_rowstride
/width
;
361 g_object_unref (G_OBJECT (mask_buf
));
368 file_for_image (Lisp_Object image
)
370 Lisp_Object specified_file
= Qnil
;
373 for (tail
= XCDR (image
);
374 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
375 tail
= XCDR (XCDR (tail
)))
376 if (EQ (XCAR (tail
), QCfile
))
377 specified_file
= XCAR (XCDR (tail
));
379 return specified_file
;
382 /* For the image defined in IMG, make and return a GtkImage. For displays with
383 8 planes or less we must make a GdkPixbuf and apply the mask manually.
384 Otherwise the highlighting and dimming the tool bar code in GTK does
385 will look bad. For display with more than 8 planes we just use the
386 pixmap and mask directly. For monochrome displays, GTK doesn't seem
387 able to use external pixmaps, it looks bad whatever we do.
388 The image is defined on the display where frame F is.
389 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
390 If OLD_WIDGET is NULL, a new widget is constructed and returned.
391 If OLD_WIDGET is not NULL, that widget is modified. */
394 xg_get_image_for_pixmap (struct frame
*f
,
397 GtkImage
*old_widget
)
401 /* If we have a file, let GTK do all the image handling.
402 This seems to be the only way to make insensitive and activated icons
403 look good in all cases. */
404 Lisp_Object specified_file
= file_for_image (img
->spec
);
407 /* We already loaded the image once before calling this
408 function, so this only fails if the image file has been removed.
409 In that case, use the pixmap already loaded. */
411 if (STRINGP (specified_file
)
412 && STRINGP (file
= x_find_image_file (specified_file
)))
415 old_widget
= GTK_IMAGE (gtk_image_new_from_file (SSDATA (file
)));
417 gtk_image_set_from_file (old_widget
, SSDATA (file
));
419 return GTK_WIDGET (old_widget
);
422 /* No file, do the image handling ourselves. This will look very bad
423 on a monochrome display, and sometimes bad on all displays with
426 /* This is a workaround to make icons look good on pseudo color
427 displays. Apparently GTK expects the images to have an alpha
428 channel. If they don't, insensitive and activated icons will
429 look bad. This workaround does not work on monochrome displays,
430 and is strictly not needed on true color/static color displays (i.e.
431 16 bits and higher). But we do it anyway so we get a pixbuf that is
432 not associated with the img->pixmap. The img->pixmap may be removed
433 by clearing the image cache and then the tool bar redraw fails, since
434 Gtk+ assumes the pixmap is always there. */
435 icon_buf
= xg_get_pixbuf_from_pix_and_mask (f
, img
->pixmap
, img
->mask
);
440 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
442 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
444 g_object_unref (G_OBJECT (icon_buf
));
447 return GTK_WIDGET (old_widget
);
451 /* Set CURSOR on W and all widgets W contain. We must do like this
452 for scroll bars and menu because they create widgets internally,
453 and it is those widgets that are visible. */
456 xg_set_cursor (GtkWidget
*w
, GdkCursor
*cursor
)
458 GdkWindow
*window
= gtk_widget_get_window (w
);
459 GList
*children
= gdk_window_peek_children (window
);
461 gdk_window_set_cursor (window
, cursor
);
463 /* The scroll bar widget has more than one GDK window (had to look at
464 the source to figure this out), and there is no way to set cursor
465 on widgets in GTK. So we must set the cursor for all GDK windows.
468 for ( ; children
; children
= g_list_next (children
))
469 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
472 /* Insert NODE into linked LIST. */
475 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
477 xg_list_node
*list_start
= list
->next
;
479 if (list_start
) list_start
->prev
= node
;
480 node
->next
= list_start
;
485 /* Remove NODE from linked LIST. */
488 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
490 xg_list_node
*list_start
= list
->next
;
491 if (node
== list_start
)
493 list
->next
= node
->next
;
494 if (list
->next
) list
->next
->prev
= 0;
498 node
->prev
->next
= node
->next
;
499 if (node
->next
) node
->next
->prev
= node
->prev
;
503 /* Allocate and return a utf8 version of STR. If STR is already
504 utf8 or NULL, just return a copy of STR.
505 A new string is allocated and the caller must free the result
509 get_utf8_string (const char *str
)
513 if (!str
) return NULL
;
515 /* If not UTF-8, try current locale. */
516 if (!g_utf8_validate (str
, -1, NULL
))
517 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
519 return g_strdup (str
);
523 /* Probably some control characters in str. Escape them. */
525 ptrdiff_t nr_bad
= 0;
528 unsigned char *p
= (unsigned char *)str
;
532 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
533 &bytes_written
, &err
))
534 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
537 p
+= bytes_written
+1;
550 if ((min (PTRDIFF_MAX
, SIZE_MAX
) - len
- 1) / 4 < nr_bad
)
551 memory_full (SIZE_MAX
);
552 up
= utf8_str
= xmalloc (len
+ nr_bad
* 4 + 1);
553 p
= (unsigned char *)str
;
555 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
556 &bytes_written
, &err
))
557 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
559 memcpy (up
, p
, bytes_written
);
560 sprintf (up
+ bytes_written
, "\\%03o", p
[bytes_written
]);
561 up
+= bytes_written
+4;
562 p
+= bytes_written
+1;
569 strcat (utf8_str
, cp
);
581 /* Check for special colors used in face spec for region face.
582 The colors are fetched from the Gtk+ theme.
583 Return true if color was found, false if not. */
586 xg_check_special_colors (struct frame
*f
,
587 const char *color_name
,
591 bool get_bg
= strcmp ("gtk_selection_bg_color", color_name
) == 0;
592 bool get_fg
= !get_bg
&& strcmp ("gtk_selection_fg_color", color_name
) == 0;
594 if (! FRAME_GTK_WIDGET (f
) || ! (get_bg
|| get_fg
))
600 GtkStyleContext
*gsty
601 = gtk_widget_get_style_context (FRAME_GTK_OUTER_WIDGET (f
));
603 char buf
[sizeof "rgb://rrrr/gggg/bbbb"];
604 int state
= GTK_STATE_FLAG_SELECTED
|GTK_STATE_FLAG_FOCUSED
;
606 gtk_style_context_get_color (gsty
, state
, &col
);
608 gtk_style_context_get_background_color (gsty
, state
, &col
);
610 sprintf (buf
, "rgb:%04x/%04x/%04x",
611 (int)(col
.red
* 65535),
612 (int)(col
.green
* 65535),
613 (int)(col
.blue
* 65535));
614 success_p
= (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
618 GtkStyle
*gsty
= gtk_widget_get_style (FRAME_GTK_WIDGET (f
));
619 GdkColor
*grgb
= get_bg
620 ? &gsty
->bg
[GTK_STATE_SELECTED
]
621 : &gsty
->fg
[GTK_STATE_SELECTED
];
623 color
->red
= grgb
->red
;
624 color
->green
= grgb
->green
;
625 color
->blue
= grgb
->blue
;
626 color
->pixel
= grgb
->pixel
;
637 /***********************************************************************
639 ***********************************************************************/
640 /* Gtk+ calls this callback when the parent of our tooltip dummy changes.
641 We use that to pop down the tooltip. This happens if Gtk+ for some
642 reason wants to change or hide the tooltip. */
644 #ifdef USE_GTK_TOOLTIP
647 hierarchy_ch_cb (GtkWidget
*widget
,
648 GtkWidget
*previous_toplevel
,
651 struct frame
*f
= user_data
;
652 struct x_output
*x
= f
->output_data
.x
;
653 GtkWidget
*top
= gtk_widget_get_toplevel (x
->ttip_lbl
);
655 if (! top
|| ! GTK_IS_WINDOW (top
))
656 gtk_widget_hide (previous_toplevel
);
659 /* Callback called when Gtk+ thinks a tooltip should be displayed.
660 We use it to get the tooltip window and the tooltip widget so
661 we can manipulate the ourselves.
663 Return FALSE ensures that the tooltip is not shown. */
666 qttip_cb (GtkWidget
*widget
,
669 gboolean keyboard_mode
,
673 struct frame
*f
= user_data
;
674 struct x_output
*x
= f
->output_data
.x
;
675 if (x
->ttip_widget
== NULL
)
680 g_object_set (G_OBJECT (widget
), "has-tooltip", FALSE
, NULL
);
681 x
->ttip_widget
= tooltip
;
682 g_object_ref (G_OBJECT (tooltip
));
683 x
->ttip_lbl
= gtk_label_new ("");
684 g_object_ref (G_OBJECT (x
->ttip_lbl
));
685 gtk_tooltip_set_custom (tooltip
, x
->ttip_lbl
);
686 x
->ttip_window
= GTK_WINDOW (gtk_widget_get_toplevel (x
->ttip_lbl
));
688 /* Change stupid Gtk+ default line wrapping. */
689 p
= gtk_widget_get_parent (x
->ttip_lbl
);
690 list
= gtk_container_get_children (GTK_CONTAINER (p
));
691 for (iter
= list
; iter
; iter
= g_list_next (iter
))
693 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
694 if (GTK_IS_LABEL (w
))
695 gtk_label_set_line_wrap (GTK_LABEL (w
), FALSE
);
699 /* ATK needs an empty title for some reason. */
700 gtk_window_set_title (x
->ttip_window
, "");
701 /* Realize so we can safely get screen later on. */
702 gtk_widget_realize (GTK_WIDGET (x
->ttip_window
));
703 gtk_widget_realize (x
->ttip_lbl
);
705 g_signal_connect (x
->ttip_lbl
, "hierarchy-changed",
706 G_CALLBACK (hierarchy_ch_cb
), f
);
711 #endif /* USE_GTK_TOOLTIP */
713 /* Prepare a tooltip to be shown, i.e. calculate WIDTH and HEIGHT.
714 Return true if a system tooltip is available. */
717 xg_prepare_tooltip (struct frame
*f
,
722 #ifndef USE_GTK_TOOLTIP
725 struct x_output
*x
= f
->output_data
.x
;
729 GtkSettings
*settings
;
730 gboolean tt_enabled
= TRUE
;
732 Lisp_Object encoded_string
;
734 if (!x
->ttip_lbl
) return 0;
737 encoded_string
= ENCODE_UTF_8 (string
);
738 widget
= GTK_WIDGET (x
->ttip_lbl
);
739 gwin
= gtk_widget_get_window (GTK_WIDGET (x
->ttip_window
));
740 screen
= gdk_window_get_screen (gwin
);
741 settings
= gtk_settings_get_for_screen (screen
);
742 g_object_get (settings
, "gtk-enable-tooltips", &tt_enabled
, NULL
);
745 g_object_set (settings
, "gtk-enable-tooltips", FALSE
, NULL
);
746 /* Record that we disabled it so it can be enabled again. */
747 g_object_set_data (G_OBJECT (x
->ttip_window
), "restore-tt",
751 /* Prevent Gtk+ from hiding tooltip on mouse move and such. */
752 g_object_set_data (G_OBJECT
753 (gtk_widget_get_display (GTK_WIDGET (x
->ttip_window
))),
754 "gdk-display-current-tooltip", NULL
);
756 /* Put our dummy widget in so we can get callbacks for unrealize and
757 hierarchy-changed. */
758 gtk_tooltip_set_custom (x
->ttip_widget
, widget
);
759 gtk_tooltip_set_text (x
->ttip_widget
, SSDATA (encoded_string
));
760 gtk_widget_get_preferred_size (GTK_WIDGET (x
->ttip_window
), NULL
, &req
);
761 if (width
) *width
= req
.width
;
762 if (height
) *height
= req
.height
;
767 #endif /* USE_GTK_TOOLTIP */
770 /* Show the tooltip at ROOT_X and ROOT_Y.
771 xg_prepare_tooltip must have been called before this function. */
774 xg_show_tooltip (struct frame
*f
, int root_x
, int root_y
)
776 #ifdef USE_GTK_TOOLTIP
777 struct x_output
*x
= f
->output_data
.x
;
781 gtk_window_move (x
->ttip_window
, root_x
, root_y
);
782 gtk_widget_show_all (GTK_WIDGET (x
->ttip_window
));
788 /* Hide tooltip if shown. Do nothing if not shown.
789 Return true if tip was hidden, false if not (i.e. not using
793 xg_hide_tooltip (struct frame
*f
)
796 #ifdef USE_GTK_TOOLTIP
797 if (f
->output_data
.x
->ttip_window
)
799 GtkWindow
*win
= f
->output_data
.x
->ttip_window
;
801 gtk_widget_hide (GTK_WIDGET (win
));
803 if (g_object_get_data (G_OBJECT (win
), "restore-tt"))
805 GdkWindow
*gwin
= gtk_widget_get_window (GTK_WIDGET (win
));
806 GdkScreen
*screen
= gdk_window_get_screen (gwin
);
807 GtkSettings
*settings
= gtk_settings_get_for_screen (screen
);
808 g_object_set (settings
, "gtk-enable-tooltips", TRUE
, NULL
);
819 /***********************************************************************
820 General functions for creating widgets, resizing, events, e.t.c.
821 ***********************************************************************/
824 my_log_handler (const gchar
*log_domain
, GLogLevelFlags log_level
,
825 const gchar
*msg
, gpointer user_data
)
827 if (!strstr (msg
, "visible children"))
828 fprintf (stderr
, "XX %s-WARNING **: %s\n", log_domain
, msg
);
831 /* Make a geometry string and pass that to GTK. It seems this is the
832 only way to get geometry position right if the user explicitly
833 asked for a position when starting Emacs.
834 F is the frame we shall set geometry for. */
837 xg_set_geometry (struct frame
*f
)
839 if (f
->size_hint_flags
& (USPosition
| PPosition
))
841 int left
= f
->left_pos
;
842 int xneg
= f
->size_hint_flags
& XNegative
;
843 int top
= f
->top_pos
;
844 int yneg
= f
->size_hint_flags
& YNegative
;
845 char geom_str
[sizeof "=x--" + 4 * INT_STRLEN_BOUND (int)];
853 sprintf (geom_str
, "=%dx%d%c%d%c%d",
854 FRAME_PIXEL_WIDTH (f
),
855 FRAME_PIXEL_HEIGHT (f
),
856 (xneg
? '-' : '+'), left
,
857 (yneg
? '-' : '+'), top
);
859 /* Silence warning about visible children. */
860 id
= g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING
| G_LOG_FLAG_FATAL
861 | G_LOG_FLAG_RECURSION
, my_log_handler
, NULL
);
863 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
865 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
867 g_log_remove_handler ("Gtk", id
);
871 /* Clear under internal border if any. As we use a mix of Gtk+ and X calls
872 and use a GtkFixed widget, this doesn't happen automatically. */
875 xg_clear_under_internal_border (struct frame
*f
)
877 if (FRAME_INTERNAL_BORDER_WIDTH (f
) > 0)
879 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
881 gtk_widget_queue_draw (wfixed
);
882 gdk_window_process_all_updates ();
884 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), 0, 0,
885 FRAME_PIXEL_WIDTH (f
), FRAME_INTERNAL_BORDER_WIDTH (f
));
887 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), 0, 0,
888 FRAME_INTERNAL_BORDER_WIDTH (f
), FRAME_PIXEL_HEIGHT (f
));
890 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), 0,
891 FRAME_PIXEL_HEIGHT (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
892 FRAME_PIXEL_WIDTH (f
), FRAME_INTERNAL_BORDER_WIDTH (f
));
894 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
895 FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
896 0, FRAME_INTERNAL_BORDER_WIDTH (f
), FRAME_PIXEL_HEIGHT (f
));
900 /* Function to handle resize of our frame. As we have a Gtk+ tool bar
901 and a Gtk+ menu bar, we get resize events for the edit part of the
902 frame only. We let Gtk+ deal with the Gtk+ parts.
903 F is the frame to resize.
904 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
907 xg_frame_resized (struct frame
*f
, int pixelwidth
, int pixelheight
)
911 if (pixelwidth
== -1 && pixelheight
== -1)
913 if (FRAME_GTK_WIDGET (f
) && gtk_widget_get_mapped (FRAME_GTK_WIDGET (f
)))
914 gdk_window_get_geometry (gtk_widget_get_window (FRAME_GTK_WIDGET (f
)),
916 &pixelwidth
, &pixelheight
);
921 width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, pixelwidth
);
922 height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, pixelheight
);
924 if (width
!= FRAME_TEXT_WIDTH (f
)
925 || height
!= FRAME_TEXT_HEIGHT (f
)
926 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
927 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
))
929 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
930 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
932 xg_clear_under_internal_border (f
);
933 change_frame_size (f
, width
, height
, 0, 1, 0, 1);
934 SET_FRAME_GARBAGED (f
);
935 cancel_mouse_face (f
);
939 /* Resize the outer window of frame F after changing the height.
940 COLUMNS/ROWS is the size the edit area shall have after the resize. */
943 xg_frame_set_char_size (struct frame
*f
, int width
, int height
)
945 int pixelwidth
= FRAME_TEXT_TO_PIXEL_WIDTH (f
, width
);
946 int pixelheight
= FRAME_TEXT_TO_PIXEL_HEIGHT (f
, height
);
948 if (FRAME_PIXEL_HEIGHT (f
) == 0)
951 /* Do this before resize, as we don't know yet if we will be resized. */
952 xg_clear_under_internal_border (f
);
954 /* Must resize our top level widget. Font size may have changed,
955 but not rows/cols. */
956 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
957 pixelwidth
+ FRAME_TOOLBAR_WIDTH (f
),
958 pixelheight
+ FRAME_TOOLBAR_HEIGHT (f
)
959 + FRAME_MENUBAR_HEIGHT (f
));
960 x_wm_set_size_hint (f
, 0, 0);
962 SET_FRAME_GARBAGED (f
);
963 cancel_mouse_face (f
);
965 /* We can not call change_frame_size for a mapped frame,
966 we can not set pixel width/height either. The window manager may
967 override our resize request, XMonad does this all the time.
968 The best we can do is try to sync, so lisp code sees the updated
969 size as fast as possible.
970 For unmapped windows, we can set rows/cols. When
971 the frame is mapped again we will (hopefully) get the correct size. */
972 if (FRAME_VISIBLE_P (f
))
974 /* Must call this to flush out events */
975 (void)gtk_events_pending ();
977 x_wait_for_event (f
, ConfigureNotify
);
980 change_frame_size (f
, width
, height
, 0, 1, 0, 1);
983 /* Handle height/width changes (i.e. add/remove/move menu/toolbar).
984 The policy is to keep the number of editable lines. */
987 xg_height_or_width_changed (struct frame
*f
)
989 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
990 FRAME_TOTAL_PIXEL_WIDTH (f
),
991 FRAME_TOTAL_PIXEL_HEIGHT (f
));
992 f
->output_data
.x
->hint_flags
= 0;
993 x_wm_set_size_hint (f
, 0, 0);
996 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
997 Must be done like this, because GtkWidget:s can have "hidden"
998 X Window that aren't accessible.
1000 Return 0 if no widget match WDESC. */
1003 xg_win_to_widget (Display
*dpy
, Window wdesc
)
1006 GtkWidget
*gwdesc
= 0;
1010 gdkwin
= gdk_x11_window_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
1015 event
.any
.window
= gdkwin
;
1016 event
.any
.type
= GDK_NOTHING
;
1017 gwdesc
= gtk_get_event_widget (&event
);
1024 /* Set the background of widget W to PIXEL. */
1027 xg_set_widget_bg (struct frame
*f
, GtkWidget
*w
, unsigned long pixel
)
1033 if (XQueryColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &xbg
))
1035 bg
.red
= (double)xbg
.red
/65535.0;
1036 bg
.green
= (double)xbg
.green
/65535.0;
1037 bg
.blue
= (double)xbg
.blue
/65535.0;
1039 gtk_widget_override_background_color (w
, GTK_STATE_FLAG_NORMAL
, &bg
);
1043 GdkColormap
*map
= gtk_widget_get_colormap (w
);
1044 gdk_colormap_query_color (map
, pixel
, &bg
);
1045 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &bg
);
1049 /* Callback called when the gtk theme changes.
1050 We notify lisp code so it can fix faces used for region for example. */
1053 style_changed_cb (GObject
*go
,
1057 struct input_event event
;
1058 GdkDisplay
*gdpy
= user_data
;
1059 const char *display_name
= gdk_display_get_name (gdpy
);
1060 Display
*dpy
= GDK_DISPLAY_XDISPLAY (gdpy
);
1063 event
.kind
= CONFIG_CHANGED_EVENT
;
1064 event
.frame_or_window
= build_string (display_name
);
1065 /* Theme doesn't change often, so intern is called seldom. */
1066 event
.arg
= intern ("theme-name");
1067 kbd_buffer_store_event (&event
);
1069 update_theme_scrollbar_width ();
1071 /* If scroll bar width changed, we need set the new size on all frames
1075 Lisp_Object rest
, frame
;
1076 FOR_EACH_FRAME (rest
, frame
)
1078 struct frame
*f
= XFRAME (frame
);
1079 if (FRAME_LIVE_P (f
)
1081 && FRAME_X_DISPLAY (f
) == dpy
)
1083 x_set_scroll_bar_default_width (f
);
1084 xg_frame_set_char_size (f
, FRAME_TEXT_WIDTH (f
), FRAME_TEXT_HEIGHT (f
));
1090 /* Called when a delete-event occurs on WIDGET. */
1093 delete_cb (GtkWidget
*widget
,
1098 /* The event doesn't arrive in the normal event loop. Send event
1100 struct frame
*f
= user_data
;
1101 struct input_event ie
;
1104 ie
.kind
= DELETE_WINDOW_EVENT
;
1105 XSETFRAME (ie
.frame_or_window
, f
);
1106 kbd_buffer_store_event (&ie
);
1112 /* Create and set up the GTK widgets for frame F.
1113 Return true if creation succeeded. */
1116 xg_create_frame_widgets (struct frame
*f
)
1119 GtkWidget
*wvbox
, *whbox
;
1128 if (FRAME_X_EMBEDDED_P (f
))
1130 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
1131 wtop
= gtk_plug_new_for_display (gdpy
, f
->output_data
.x
->parent_desc
);
1134 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
1136 /* gtk_window_set_has_resize_grip is a Gtk+ 3.0 function but Ubuntu
1137 has backported it to Gtk+ 2.0 and they add the resize grip for
1138 Gtk+ 2.0 applications also. But it has a bug that makes Emacs loop
1139 forever, so disable the grip. */
1140 #if (! GTK_CHECK_VERSION (3, 0, 0) \
1141 && defined HAVE_GTK_WINDOW_SET_HAS_RESIZE_GRIP)
1142 gtk_window_set_has_resize_grip (GTK_WINDOW (wtop
), FALSE
);
1145 xg_set_screen (wtop
, f
);
1147 wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1148 whbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1149 gtk_box_set_homogeneous (GTK_BOX (wvbox
), FALSE
);
1150 gtk_box_set_homogeneous (GTK_BOX (whbox
), FALSE
);
1153 wfixed
= emacs_fixed_new (f
);
1155 wfixed
= gtk_fixed_new ();
1158 if (! wtop
|| ! wvbox
|| ! whbox
|| ! wfixed
)
1160 if (wtop
) gtk_widget_destroy (wtop
);
1161 if (wvbox
) gtk_widget_destroy (wvbox
);
1162 if (whbox
) gtk_widget_destroy (whbox
);
1163 if (wfixed
) gtk_widget_destroy (wfixed
);
1169 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
1170 gtk_widget_set_name (wtop
, EMACS_CLASS
);
1171 gtk_widget_set_name (wvbox
, "pane");
1172 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
1174 /* If this frame has a title or name, set it in the title bar. */
1175 if (! NILP (f
->title
))
1176 title
= SSDATA (ENCODE_UTF_8 (f
->title
));
1177 else if (! NILP (f
->name
))
1178 title
= SSDATA (ENCODE_UTF_8 (f
->name
));
1180 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
1182 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
1183 FRAME_GTK_WIDGET (f
) = wfixed
;
1184 f
->output_data
.x
->vbox_widget
= wvbox
;
1185 f
->output_data
.x
->hbox_widget
= whbox
;
1187 gtk_widget_set_has_window (wfixed
, TRUE
);
1189 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
1190 gtk_box_pack_start (GTK_BOX (wvbox
), whbox
, TRUE
, TRUE
, 0);
1191 gtk_box_pack_start (GTK_BOX (whbox
), wfixed
, TRUE
, TRUE
, 0);
1193 if (FRAME_EXTERNAL_TOOL_BAR (f
))
1194 update_frame_tool_bar (f
);
1196 /* We don't want this widget double buffered, because we draw on it
1197 with regular X drawing primitives, so from a GTK/GDK point of
1198 view, the widget is totally blank. When an expose comes, this
1199 will make the widget blank, and then Emacs redraws it. This flickers
1200 a lot, so we turn off double buffering. */
1201 gtk_widget_set_double_buffered (wfixed
, FALSE
);
1203 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
1204 SSDATA (Vx_resource_name
),
1205 SSDATA (Vx_resource_class
));
1207 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
1208 GTK is to destroy the widget. We want Emacs to do that instead. */
1209 g_signal_connect (G_OBJECT (wtop
), "delete-event",
1210 G_CALLBACK (delete_cb
), f
);
1212 /* Convert our geometry parameters into a geometry string
1214 GTK will itself handle calculating the real position this way. */
1215 xg_set_geometry (f
);
1217 = gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1219 gtk_widget_add_events (wfixed
,
1220 GDK_POINTER_MOTION_MASK
1222 | GDK_BUTTON_PRESS_MASK
1223 | GDK_BUTTON_RELEASE_MASK
1224 | GDK_KEY_PRESS_MASK
1225 | GDK_ENTER_NOTIFY_MASK
1226 | GDK_LEAVE_NOTIFY_MASK
1227 | GDK_FOCUS_CHANGE_MASK
1228 | GDK_STRUCTURE_MASK
1229 | GDK_VISIBILITY_NOTIFY_MASK
);
1231 /* Must realize the windows so the X window gets created. It is used
1232 by callers of this function. */
1233 gtk_widget_realize (wfixed
);
1234 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
1236 /* Since GTK clears its window by filling with the background color,
1237 we must keep X and GTK background in sync. */
1238 xg_set_widget_bg (f
, wfixed
, FRAME_BACKGROUND_PIXEL (f
));
1241 /* Also, do not let any background pixmap to be set, this looks very
1242 bad as Emacs overwrites the background pixmap with its own idea
1243 of background color. */
1244 style
= gtk_widget_get_modifier_style (wfixed
);
1246 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
1247 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
1248 gtk_widget_modify_style (wfixed
, style
);
1250 gtk_widget_set_can_focus (wfixed
, TRUE
);
1251 gtk_window_set_resizable (GTK_WINDOW (wtop
), TRUE
);
1254 #ifdef USE_GTK_TOOLTIP
1255 /* Steal a tool tip window we can move ourselves. */
1256 f
->output_data
.x
->ttip_widget
= 0;
1257 f
->output_data
.x
->ttip_lbl
= 0;
1258 f
->output_data
.x
->ttip_window
= 0;
1259 gtk_widget_set_tooltip_text (wtop
, "Dummy text");
1260 g_signal_connect (wtop
, "query-tooltip", G_CALLBACK (qttip_cb
), f
);
1264 GdkScreen
*screen
= gtk_widget_get_screen (wtop
);
1265 GtkSettings
*gs
= gtk_settings_get_for_screen (screen
);
1266 /* Only connect this signal once per screen. */
1267 if (! g_signal_handler_find (G_OBJECT (gs
),
1268 G_SIGNAL_MATCH_FUNC
,
1270 G_CALLBACK (style_changed_cb
),
1273 g_signal_connect (G_OBJECT (gs
), "notify::gtk-theme-name",
1274 G_CALLBACK (style_changed_cb
),
1275 gdk_screen_get_display (screen
));
1285 xg_free_frame_widgets (struct frame
*f
)
1287 if (FRAME_GTK_OUTER_WIDGET (f
))
1289 #ifdef USE_GTK_TOOLTIP
1290 struct x_output
*x
= f
->output_data
.x
;
1292 struct xg_frame_tb_info
*tbinfo
1293 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
1298 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f
));
1299 FRAME_X_WINDOW (f
) = 0; /* Set to avoid XDestroyWindow in xterm.c */
1300 FRAME_GTK_OUTER_WIDGET (f
) = 0;
1301 #ifdef USE_GTK_TOOLTIP
1303 gtk_widget_destroy (x
->ttip_lbl
);
1305 g_object_unref (G_OBJECT (x
->ttip_widget
));
1310 /* Set the normal size hints for the window manager, for frame F.
1311 FLAGS is the flags word to use--or 0 meaning preserve the flags
1312 that the window now has.
1313 If USER_POSITION, set the User Position
1314 flag (this is useful when FLAGS is 0). */
1317 x_wm_set_size_hint (struct frame
*f
, long int flags
, bool user_position
)
1319 /* Must use GTK routines here, otherwise GTK resets the size hints
1320 to its own defaults. */
1321 GdkGeometry size_hints
;
1322 gint hint_flags
= 0;
1323 int base_width
, base_height
;
1324 int min_rows
= 0, min_cols
= 0;
1325 int win_gravity
= f
->win_gravity
;
1326 Lisp_Object fs_state
, frame
;
1328 /* Don't set size hints during initialization; that apparently leads
1329 to a race condition. See the thread at
1330 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
1331 if (NILP (Vafter_init_time
) || !FRAME_GTK_OUTER_WIDGET (f
))
1334 XSETFRAME (frame
, f
);
1335 fs_state
= Fframe_parameter (frame
, Qfullscreen
);
1336 if (EQ (fs_state
, Qmaximized
) || EQ (fs_state
, Qfullboth
))
1338 /* Don't set hints when maximized or fullscreen. Apparently KWin and
1339 Gtk3 don't get along and the frame shrinks (!).
1346 memset (&size_hints
, 0, sizeof (size_hints
));
1347 f
->output_data
.x
->size_hints
= size_hints
;
1348 f
->output_data
.x
->hint_flags
= hint_flags
;
1351 flags
= f
->size_hint_flags
;
1353 size_hints
= f
->output_data
.x
->size_hints
;
1354 hint_flags
= f
->output_data
.x
->hint_flags
;
1356 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
1357 size_hints
.width_inc
= frame_resize_pixelwise
? 1 : FRAME_COLUMN_WIDTH (f
);
1358 size_hints
.height_inc
= frame_resize_pixelwise
? 1 : FRAME_LINE_HEIGHT (f
);
1360 hint_flags
|= GDK_HINT_BASE_SIZE
;
1361 /* Use one row/col here so base_height/width does not become zero.
1362 Gtk+ and/or Unity on Ubuntu 12.04 can't handle it. */
1363 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 1) + FRAME_TOOLBAR_WIDTH (f
);
1364 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 1)
1365 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
1367 check_frame_size (f
, &min_cols
, &min_rows
, 0);
1368 if (min_cols
> 0) --min_cols
; /* We used one col in base_width = ... 1); */
1369 if (min_rows
> 0) --min_rows
; /* We used one row in base_height = ... 1); */
1371 size_hints
.base_width
= base_width
;
1372 size_hints
.base_height
= base_height
;
1373 size_hints
.min_width
= base_width
+ min_cols
* FRAME_COLUMN_WIDTH (f
);;
1374 size_hints
.min_height
= base_height
+ min_rows
* FRAME_LINE_HEIGHT (f
);
1376 /* These currently have a one to one mapping with the X values, but I
1377 don't think we should rely on that. */
1378 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
1379 size_hints
.win_gravity
= 0;
1380 if (win_gravity
== NorthWestGravity
)
1381 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
1382 else if (win_gravity
== NorthGravity
)
1383 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
1384 else if (win_gravity
== NorthEastGravity
)
1385 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
1386 else if (win_gravity
== WestGravity
)
1387 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
1388 else if (win_gravity
== CenterGravity
)
1389 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
1390 else if (win_gravity
== EastGravity
)
1391 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
1392 else if (win_gravity
== SouthWestGravity
)
1393 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
1394 else if (win_gravity
== SouthGravity
)
1395 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
1396 else if (win_gravity
== SouthEastGravity
)
1397 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
1398 else if (win_gravity
== StaticGravity
)
1399 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
1403 hint_flags
&= ~GDK_HINT_POS
;
1404 hint_flags
|= GDK_HINT_USER_POS
;
1407 if (hint_flags
!= f
->output_data
.x
->hint_flags
1408 || memcmp (&size_hints
,
1409 &f
->output_data
.x
->size_hints
,
1410 sizeof (size_hints
)) != 0)
1413 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1414 NULL
, &size_hints
, hint_flags
);
1415 f
->output_data
.x
->size_hints
= size_hints
;
1416 f
->output_data
.x
->hint_flags
= hint_flags
;
1421 /* Change background color of a frame.
1422 Since GTK uses the background color to clear the window, we must
1423 keep the GTK and X colors in sync.
1424 F is the frame to change,
1425 BG is the pixel value to change to. */
1428 xg_set_background_color (struct frame
*f
, unsigned long bg
)
1430 if (FRAME_GTK_WIDGET (f
))
1433 xg_set_widget_bg (f
, FRAME_GTK_WIDGET (f
), FRAME_BACKGROUND_PIXEL (f
));
1439 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1440 functions so GTK does not overwrite the icon. */
1443 xg_set_frame_icon (struct frame
*f
, Pixmap icon_pixmap
, Pixmap icon_mask
)
1445 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (f
,
1449 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
1454 /***********************************************************************
1456 ***********************************************************************/
1457 /* Return the dialog title to use for a dialog of type KEY.
1458 This is the encoding used by lwlib. We use the same for GTK. */
1461 get_dialog_title (char key
)
1463 const char *title
= "";
1471 title
= "Information";
1490 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1491 the dialog, but return TRUE so the event does not propagate further
1492 in GTK. This prevents GTK from destroying the dialog widget automatically
1493 and we can always destroy the widget manually, regardless of how
1494 it was popped down (button press or WM_DELETE_WINDOW).
1495 W is the dialog widget.
1496 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1497 user_data is NULL (not used).
1499 Returns TRUE to end propagation of event. */
1502 dialog_delete_callback (GtkWidget
*w
, GdkEvent
*event
, gpointer user_data
)
1504 gtk_widget_unmap (w
);
1508 /* Create a popup dialog window. See also xg_create_widget below.
1509 WV is a widget_value describing the dialog.
1510 SELECT_CB is the callback to use when a button has been pressed.
1511 DEACTIVATE_CB is the callback to use when the dialog pops down.
1513 Returns the GTK dialog widget. */
1516 create_dialog (widget_value
*wv
,
1517 GCallback select_cb
,
1518 GCallback deactivate_cb
)
1520 const char *title
= get_dialog_title (wv
->name
[0]);
1521 int total_buttons
= wv
->name
[1] - '0';
1522 int right_buttons
= wv
->name
[4] - '0';
1525 int button_spacing
= 10;
1526 GtkWidget
*wdialog
= gtk_dialog_new ();
1527 GtkDialog
*wd
= GTK_DIALOG (wdialog
);
1528 GtkBox
*cur_box
= GTK_BOX (gtk_dialog_get_action_area (wd
));
1530 GtkWidget
*whbox_down
;
1532 /* If the number of buttons is greater than 4, make two rows of buttons
1533 instead. This looks better. */
1534 bool make_two_rows
= total_buttons
> 4;
1536 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1537 left_buttons
= total_buttons
- right_buttons
;
1539 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1540 gtk_widget_set_name (wdialog
, "emacs-dialog");
1545 GtkWidget
*wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, button_spacing
);
1546 GtkWidget
*whbox_up
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1547 gtk_box_set_homogeneous (GTK_BOX (wvbox
), TRUE
);
1548 gtk_box_set_homogeneous (GTK_BOX (whbox_up
), FALSE
);
1549 whbox_down
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1550 gtk_box_set_homogeneous (GTK_BOX (whbox_down
), FALSE
);
1552 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1553 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1554 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1556 cur_box
= GTK_BOX (whbox_up
);
1559 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1560 G_CALLBACK (dialog_delete_callback
), 0);
1564 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1565 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1568 for (item
= wv
->contents
; item
; item
= item
->next
)
1570 char *utf8_label
= get_utf8_string (item
->value
);
1574 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1576 GtkBox
*wvbox
= GTK_BOX (gtk_dialog_get_content_area (wd
));
1577 /* This is the text part of the dialog. */
1578 w
= gtk_label_new (utf8_label
);
1579 gtk_box_pack_start (wvbox
, gtk_label_new (""), FALSE
, FALSE
, 0);
1580 gtk_box_pack_start (wvbox
, w
, TRUE
, TRUE
, 0);
1581 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1583 /* Try to make dialog look better. Must realize first so
1584 the widget can calculate the size it needs. */
1585 gtk_widget_realize (w
);
1586 gtk_widget_get_preferred_size (w
, NULL
, &req
);
1587 gtk_box_set_spacing (wvbox
, req
.height
);
1588 if (item
->value
&& strlen (item
->value
) > 0)
1589 button_spacing
= 2*req
.width
/strlen (item
->value
);
1593 /* This is one button to add to the dialog. */
1594 w
= gtk_button_new_with_label (utf8_label
);
1595 if (! item
->enabled
)
1596 gtk_widget_set_sensitive (w
, FALSE
);
1598 g_signal_connect (G_OBJECT (w
), "clicked",
1599 select_cb
, item
->call_data
);
1601 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1602 if (++button_nr
== left_buttons
)
1605 cur_box
= GTK_BOX (whbox_down
);
1607 gtk_box_pack_start (cur_box
,
1615 g_free (utf8_label
);
1621 struct xg_dialog_data
1629 /* Function that is called when the file or font dialogs pop down.
1630 W is the dialog widget, RESPONSE is the response code.
1631 USER_DATA is what we passed in to g_signal_connect. */
1634 xg_dialog_response_cb (GtkDialog
*w
,
1638 struct xg_dialog_data
*dd
= user_data
;
1639 dd
->response
= response
;
1640 g_main_loop_quit (dd
->loop
);
1644 /* Destroy the dialog. This makes it pop down. */
1647 pop_down_dialog (void *arg
)
1649 struct xg_dialog_data
*dd
= arg
;
1652 if (dd
->w
) gtk_widget_destroy (dd
->w
);
1653 if (dd
->timerid
!= 0) g_source_remove (dd
->timerid
);
1655 g_main_loop_quit (dd
->loop
);
1656 g_main_loop_unref (dd
->loop
);
1661 /* If there are any emacs timers pending, add a timeout to main loop in DATA.
1662 We pass in DATA as gpointer* so we can use this as a callback. */
1665 xg_maybe_add_timer (gpointer data
)
1667 struct xg_dialog_data
*dd
= data
;
1668 struct timespec next_time
= timer_check ();
1672 if (timespec_valid_p (next_time
))
1674 time_t s
= next_time
.tv_sec
;
1675 int per_ms
= TIMESPEC_RESOLUTION
/ 1000;
1676 int ms
= (next_time
.tv_nsec
+ per_ms
- 1) / per_ms
;
1677 if (s
<= ((guint
) -1 - ms
) / 1000)
1678 dd
->timerid
= g_timeout_add (s
* 1000 + ms
, xg_maybe_add_timer
, dd
);
1684 /* Pops up a modal dialog W and waits for response.
1685 We don't use gtk_dialog_run because we want to process emacs timers.
1686 The dialog W is not destroyed when this function returns. */
1689 xg_dialog_run (struct frame
*f
, GtkWidget
*w
)
1691 ptrdiff_t count
= SPECPDL_INDEX ();
1692 struct xg_dialog_data dd
;
1694 xg_set_screen (w
, f
);
1695 gtk_window_set_transient_for (GTK_WINDOW (w
),
1696 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1697 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1698 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1700 dd
.loop
= g_main_loop_new (NULL
, FALSE
);
1701 dd
.response
= GTK_RESPONSE_CANCEL
;
1705 g_signal_connect (G_OBJECT (w
),
1707 G_CALLBACK (xg_dialog_response_cb
),
1709 /* Don't destroy the widget if closed by the window manager close button. */
1710 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1711 gtk_widget_show (w
);
1713 record_unwind_protect_ptr (pop_down_dialog
, &dd
);
1715 (void) xg_maybe_add_timer (&dd
);
1716 g_main_loop_run (dd
.loop
);
1719 unbind_to (count
, Qnil
);
1725 /***********************************************************************
1726 File dialog functions
1727 ***********************************************************************/
1728 /* Return true if the old file selection dialog is being used. */
1731 xg_uses_old_file_dialog (void)
1733 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1734 return x_gtk_use_old_file_dialog
;
1741 typedef char * (*xg_get_file_func
) (GtkWidget
*);
1743 /* Return the selected file for file chooser dialog W.
1744 The returned string must be free:d. */
1747 xg_get_file_name_from_chooser (GtkWidget
*w
)
1749 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1752 /* Callback called when the "Show hidden files" toggle is pressed.
1753 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1756 xg_toggle_visibility_cb (GtkWidget
*widget
, gpointer data
)
1758 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1760 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1761 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1765 /* Callback called when a property changes in a file chooser.
1766 GOBJECT is the file chooser dialog, ARG1 describes the property.
1767 USER_DATA is the toggle widget in the file chooser dialog.
1768 We use this to update the "Show hidden files" toggle when the user
1769 changes that property by right clicking in the file list. */
1772 xg_toggle_notify_cb (GObject
*gobject
, GParamSpec
*arg1
, gpointer user_data
)
1774 if (strcmp (arg1
->name
, "show-hidden") == 0)
1776 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1777 gboolean visible
, toggle_on
;
1779 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1780 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1782 if (!!visible
!= !!toggle_on
)
1784 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1785 G_CALLBACK (xg_toggle_visibility_cb
),
1787 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1788 g_signal_handlers_unblock_by_func
1789 (G_OBJECT (wtoggle
),
1790 G_CALLBACK (xg_toggle_visibility_cb
),
1793 x_gtk_show_hidden_files
= visible
;
1797 /* Read a file name from the user using a file chooser dialog.
1798 F is the current frame.
1799 PROMPT is a prompt to show to the user. May not be NULL.
1800 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1801 If MUSTMATCH_P, the returned file name must be an existing
1802 file. (Actually, this only has cosmetic effects, the user can
1803 still enter a non-existing file.) *FUNC is set to a function that
1804 can be used to retrieve the selected file name from the returned widget.
1806 Returns the created widget. */
1809 xg_get_file_with_chooser (struct frame
*f
,
1811 char *default_filename
,
1812 bool mustmatch_p
, bool only_dir_p
,
1813 xg_get_file_func
*func
)
1817 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
IF_LINT (= NULL
);
1818 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1819 GtkFileChooserAction action
= (mustmatch_p
?
1820 GTK_FILE_CHOOSER_ACTION_OPEN
:
1821 GTK_FILE_CHOOSER_ACTION_SAVE
);
1824 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1826 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1827 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1828 (mustmatch_p
|| only_dir_p
?
1829 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1832 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1834 wbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1835 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
1836 gtk_widget_show (wbox
);
1837 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1839 if (x_gtk_show_hidden_files
)
1841 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1842 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1844 gtk_widget_show (wtoggle
);
1845 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1846 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1847 g_signal_connect (G_OBJECT (filewin
), "notify",
1848 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1850 if (x_gtk_file_dialog_help_text
)
1853 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1854 Show the C-l help text only for versions < 2.10. */
1855 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1856 strcat (msgbuf
, "\nType C-l to display a file name text entry box.\n");
1857 strcat (msgbuf
, "\nIf you don't like this file selector, use the "
1858 "corresponding\nkey binding or customize "
1859 "use-file-dialog to turn it off.");
1861 wmessage
= gtk_label_new (msgbuf
);
1862 gtk_widget_show (wmessage
);
1865 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1866 if (x_gtk_file_dialog_help_text
)
1867 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1868 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1870 if (default_filename
)
1873 struct gcpro gcpro1
;
1874 char *utf8_filename
;
1877 file
= build_string (default_filename
);
1879 /* File chooser does not understand ~/... in the file name. It must be
1880 an absolute name starting with /. */
1881 if (default_filename
[0] != '/')
1882 file
= Fexpand_file_name (file
, Qnil
);
1884 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1885 if (! NILP (Ffile_directory_p (file
)))
1886 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1890 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1892 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1894 char *cp
= strrchr (utf8_filename
, '/');
1896 else cp
= utf8_filename
;
1897 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1904 *func
= xg_get_file_name_from_chooser
;
1908 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1910 /* Return the selected file for file selector dialog W.
1911 The returned string must be free:d. */
1914 xg_get_file_name_from_selector (GtkWidget
*w
)
1916 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1917 return xstrdup (gtk_file_selection_get_filename (filesel
));
1920 /* Create a file selection dialog.
1921 F is the current frame.
1922 PROMPT is a prompt to show to the user. May not be NULL.
1923 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1924 If MUSTMATCH_P, the returned file name must be an existing
1925 file. *FUNC is set to a function that can be used to retrieve the
1926 selected file name from the returned widget.
1928 Returns the created widget. */
1931 xg_get_file_with_selection (struct frame
*f
,
1933 char *default_filename
,
1934 bool mustmatch_p
, bool only_dir_p
,
1935 xg_get_file_func
*func
)
1938 GtkFileSelection
*filesel
;
1940 filewin
= gtk_file_selection_new (prompt
);
1941 filesel
= GTK_FILE_SELECTION (filewin
);
1943 if (default_filename
)
1944 gtk_file_selection_set_filename (filesel
, default_filename
);
1948 /* The selection_entry part of filesel is not documented. */
1949 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1950 gtk_file_selection_hide_fileop_buttons (filesel
);
1953 *func
= xg_get_file_name_from_selector
;
1957 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1959 /* Read a file name from the user using a file dialog, either the old
1960 file selection dialog, or the new file chooser dialog. Which to use
1961 depends on what the GTK version used has, and what the value of
1962 gtk-use-old-file-dialog.
1963 F is the current frame.
1964 PROMPT is a prompt to show to the user. May not be NULL.
1965 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1966 If MUSTMATCH_P, the returned file name must be an existing
1969 Returns a file name or NULL if no file was selected.
1970 The returned string must be freed by the caller. */
1973 xg_get_file_name (struct frame
*f
,
1975 char *default_filename
,
1981 int filesel_done
= 0;
1982 xg_get_file_func func
;
1984 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1986 if (xg_uses_old_file_dialog ())
1987 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1988 mustmatch_p
, only_dir_p
, &func
);
1990 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1991 mustmatch_p
, only_dir_p
, &func
);
1993 #else /* not HAVE_GTK_FILE_SELECTION_NEW */
1994 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1995 mustmatch_p
, only_dir_p
, &func
);
1996 #endif /* not HAVE_GTK_FILE_SELECTION_NEW */
1998 gtk_widget_set_name (w
, "emacs-filedialog");
2000 filesel_done
= xg_dialog_run (f
, w
);
2001 if (filesel_done
== GTK_RESPONSE_OK
)
2004 gtk_widget_destroy (w
);
2008 /***********************************************************************
2010 ***********************************************************************/
2012 #ifdef HAVE_FREETYPE
2014 #if USE_NEW_GTK_FONT_CHOOSER
2016 #define XG_WEIGHT_TO_SYMBOL(w) \
2017 (w <= PANGO_WEIGHT_THIN ? Qextra_light \
2018 : w <= PANGO_WEIGHT_ULTRALIGHT ? Qlight \
2019 : w <= PANGO_WEIGHT_LIGHT ? Qsemi_light \
2020 : w < PANGO_WEIGHT_MEDIUM ? Qnormal \
2021 : w <= PANGO_WEIGHT_SEMIBOLD ? Qsemi_bold \
2022 : w <= PANGO_WEIGHT_BOLD ? Qbold \
2023 : w <= PANGO_WEIGHT_HEAVY ? Qextra_bold \
2026 #define XG_STYLE_TO_SYMBOL(s) \
2027 (s == PANGO_STYLE_OBLIQUE ? Qoblique \
2028 : s == PANGO_STYLE_ITALIC ? Qitalic \
2031 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2034 static char *x_last_font_name
;
2036 /* Pop up a GTK font selector and return the name of the font the user
2037 selects, as a C string. The returned font name follows GTK's own
2040 `FAMILY [VALUE1 VALUE2] SIZE'
2042 This can be parsed using font_parse_fcname in font.c.
2043 DEFAULT_NAME, if non-zero, is the default font name. */
2046 xg_get_font (struct frame
*f
, const char *default_name
)
2050 Lisp_Object font
= Qnil
;
2052 w
= gtk_font_chooser_dialog_new
2053 ("Pick a font", GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2057 /* Convert fontconfig names to Gtk names, i.e. remove - before
2059 char *p
= strrchr (default_name
, '-');
2063 while (c_isdigit (*ep
))
2065 if (*ep
== '\0') *p
= ' ';
2068 else if (x_last_font_name
)
2069 default_name
= x_last_font_name
;
2072 gtk_font_chooser_set_font (GTK_FONT_CHOOSER (w
), default_name
);
2074 gtk_widget_set_name (w
, "emacs-fontdialog");
2075 done
= xg_dialog_run (f
, w
);
2076 if (done
== GTK_RESPONSE_OK
)
2078 #if USE_NEW_GTK_FONT_CHOOSER
2079 /* Use the GTK3 font chooser. */
2080 PangoFontDescription
*desc
2081 = gtk_font_chooser_get_font_desc (GTK_FONT_CHOOSER (w
));
2085 Lisp_Object args
[10];
2086 const char *name
= pango_font_description_get_family (desc
);
2087 gint size
= pango_font_description_get_size (desc
);
2088 PangoWeight weight
= pango_font_description_get_weight (desc
);
2089 PangoStyle style
= pango_font_description_get_style (desc
);
2092 args
[1] = build_string (name
);
2095 args
[3] = make_float (pango_units_to_double (size
));
2098 args
[5] = XG_WEIGHT_TO_SYMBOL (weight
);
2101 args
[7] = XG_STYLE_TO_SYMBOL (style
);
2106 font
= Ffont_spec (8, args
);
2108 pango_font_description_free (desc
);
2109 xfree (x_last_font_name
);
2110 x_last_font_name
= xstrdup (name
);
2113 #else /* Use old font selector, which just returns the font name. */
2116 = gtk_font_selection_dialog_get_font_name (GTK_FONT_CHOOSER (w
));
2120 font
= build_string (font_name
);
2121 g_free (x_last_font_name
);
2122 x_last_font_name
= font_name
;
2124 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2127 gtk_widget_destroy (w
);
2130 #endif /* HAVE_FREETYPE */
2134 /***********************************************************************
2136 ***********************************************************************/
2138 /* The name of menu items that can be used for customization. Since GTK
2139 RC files are very crude and primitive, we have to set this on all
2140 menu item names so a user can easily customize menu items. */
2142 #define MENU_ITEM_NAME "emacs-menuitem"
2145 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
2146 during GC. The next member points to the items. */
2147 static xg_list_node xg_menu_cb_list
;
2149 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
2150 during GC. The next member points to the items. */
2151 static xg_list_node xg_menu_item_cb_list
;
2153 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
2154 F is the frame CL_DATA will be initialized for.
2155 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2157 The menu bar and all sub menus under the menu bar in a frame
2158 share the same structure, hence the reference count.
2160 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
2161 allocated xg_menu_cb_data if CL_DATA is NULL. */
2163 static xg_menu_cb_data
*
2164 make_cl_data (xg_menu_cb_data
*cl_data
, struct frame
*f
, GCallback highlight_cb
)
2168 cl_data
= xmalloc (sizeof *cl_data
);
2170 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2171 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2172 cl_data
->highlight_cb
= highlight_cb
;
2173 cl_data
->ref_count
= 0;
2175 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
2178 cl_data
->ref_count
++;
2183 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
2184 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2186 When the menu bar is updated, menu items may have been added and/or
2187 removed, so menu_bar_vector and menu_bar_items_used change. We must
2188 then update CL_DATA since it is used to determine which menu
2189 item that is invoked in the menu.
2190 HIGHLIGHT_CB could change, there is no check that the same
2191 function is given when modifying a menu bar as was given when
2192 creating the menu bar. */
2195 update_cl_data (xg_menu_cb_data
*cl_data
,
2197 GCallback highlight_cb
)
2202 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2203 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2204 cl_data
->highlight_cb
= highlight_cb
;
2208 /* Decrease reference count for CL_DATA.
2209 If reference count is zero, free CL_DATA. */
2212 unref_cl_data (xg_menu_cb_data
*cl_data
)
2214 if (cl_data
&& cl_data
->ref_count
> 0)
2216 cl_data
->ref_count
--;
2217 if (cl_data
->ref_count
== 0)
2219 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
2225 /* Function that marks all lisp data during GC. */
2231 Lisp_Object rest
, frame
;
2233 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
2234 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
2236 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
2238 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
2240 if (! NILP (cb_data
->help
))
2241 mark_object (cb_data
->help
);
2244 FOR_EACH_FRAME (rest
, frame
)
2246 struct frame
*f
= XFRAME (frame
);
2248 if (FRAME_X_P (f
) && FRAME_GTK_OUTER_WIDGET (f
))
2250 struct xg_frame_tb_info
*tbinfo
2251 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
2255 mark_object (tbinfo
->last_tool_bar
);
2256 mark_object (tbinfo
->style
);
2263 /* Callback called when a menu item is destroyed. Used to free data.
2264 W is the widget that is being destroyed (not used).
2265 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
2268 menuitem_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2272 xg_menu_item_cb_data
*data
= client_data
;
2273 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
2278 /* Callback called when the pointer enters/leaves a menu item.
2279 W is the parent of the menu item.
2280 EVENT is either an enter event or leave event.
2281 CLIENT_DATA is not used.
2283 Returns FALSE to tell GTK to keep processing this event. */
2286 menuitem_highlight_callback (GtkWidget
*w
,
2287 GdkEventCrossing
*event
,
2288 gpointer client_data
)
2291 GtkWidget
*subwidget
;
2292 xg_menu_item_cb_data
*data
;
2294 ev
.crossing
= *event
;
2295 subwidget
= gtk_get_event_widget (&ev
);
2296 data
= g_object_get_data (G_OBJECT (subwidget
), XG_ITEM_DATA
);
2299 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
2301 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
2302 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
2303 (*func
) (subwidget
, call_data
);
2310 /* Callback called when a menu is destroyed. Used to free data.
2311 W is the widget that is being destroyed (not used).
2312 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
2315 menu_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2317 unref_cl_data (client_data
);
2320 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
2321 must be non-NULL) and can be inserted into a menu item.
2323 Returns the GtkHBox. */
2326 make_widget_for_menu_item (const char *utf8_label
, const char *utf8_key
)
2332 wbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
2333 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
2334 wlbl
= gtk_label_new (utf8_label
);
2335 wkey
= gtk_label_new (utf8_key
);
2337 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
2338 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
2340 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
2341 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
2343 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
2344 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
2345 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
2350 /* Make and return a menu item widget with the key to the right.
2351 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
2352 UTF8_KEY is the text representing the key binding.
2353 ITEM is the widget_value describing the menu item.
2355 GROUP is an in/out parameter. If the menu item to be created is not
2356 part of any radio menu group, *GROUP contains NULL on entry and exit.
2357 If the menu item to be created is part of a radio menu group, on entry
2358 *GROUP contains the group to use, or NULL if this is the first item
2359 in the group. On exit, *GROUP contains the radio item group.
2361 Unfortunately, keys don't line up as nicely as in Motif,
2362 but the MacOS X version doesn't either, so I guess that is OK. */
2365 make_menu_item (const char *utf8_label
,
2366 const char *utf8_key
,
2371 GtkWidget
*wtoadd
= 0;
2373 /* It has been observed that some menu items have a NULL name field.
2374 This will lead to this function being called with a NULL utf8_label.
2375 GTK crashes on that so we set a blank label. Why there is a NULL
2376 name remains to be investigated. */
2377 if (! utf8_label
) utf8_label
= " ";
2380 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2382 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
2385 if (utf8_key
) w
= gtk_check_menu_item_new ();
2386 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
2387 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
2389 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
2391 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
2392 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
2393 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
2395 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
2400 if (utf8_key
) w
= gtk_menu_item_new ();
2401 else w
= gtk_menu_item_new_with_label (utf8_label
);
2404 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2405 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
2410 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
2412 static int xg_detached_menus
;
2414 /* Return true if there are detached menus. */
2417 xg_have_tear_offs (void)
2419 return xg_detached_menus
> 0;
2422 /* Callback invoked when a detached menu window is removed. Here we
2423 decrease the xg_detached_menus count.
2424 WIDGET is the top level window that is removed (the parent of the menu).
2425 CLIENT_DATA is not used. */
2428 tearoff_remove (GtkWidget
*widget
, gpointer client_data
)
2430 if (xg_detached_menus
> 0) --xg_detached_menus
;
2433 /* Callback invoked when a menu is detached. It increases the
2434 xg_detached_menus count.
2435 WIDGET is the GtkTearoffMenuItem.
2436 CLIENT_DATA is not used. */
2439 tearoff_activate (GtkWidget
*widget
, gpointer client_data
)
2441 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
2442 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
2444 ++xg_detached_menus
;
2445 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
2447 G_CALLBACK (tearoff_remove
), 0);
2450 #else /* ! HAVE_GTK_TEAROFF_MENU_ITEM_NEW */
2452 xg_have_tear_offs (void)
2456 #endif /* ! HAVE_GTK_TEAROFF_MENU_ITEM_NEW */
2458 /* Create a menu item widget, and connect the callbacks.
2459 ITEM describes the menu item.
2460 F is the frame the created menu belongs to.
2461 SELECT_CB is the callback to use when a menu item is selected.
2462 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2463 CL_DATA points to the callback data to be used for this menu.
2464 GROUP is an in/out parameter. If the menu item to be created is not
2465 part of any radio menu group, *GROUP contains NULL on entry and exit.
2466 If the menu item to be created is part of a radio menu group, on entry
2467 *GROUP contains the group to use, or NULL if this is the first item
2468 in the group. On exit, *GROUP contains the radio item group.
2470 Returns the created GtkWidget. */
2473 xg_create_one_menuitem (widget_value
*item
,
2475 GCallback select_cb
,
2476 GCallback highlight_cb
,
2477 xg_menu_cb_data
*cl_data
,
2483 xg_menu_item_cb_data
*cb_data
;
2485 utf8_label
= get_utf8_string (item
->name
);
2486 utf8_key
= get_utf8_string (item
->key
);
2488 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2490 if (utf8_label
) g_free (utf8_label
);
2491 if (utf8_key
) g_free (utf8_key
);
2493 cb_data
= xmalloc (sizeof *cb_data
);
2495 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
2497 cb_data
->select_id
= 0;
2498 cb_data
->help
= item
->help
;
2499 cb_data
->cl_data
= cl_data
;
2500 cb_data
->call_data
= item
->call_data
;
2502 g_signal_connect (G_OBJECT (w
),
2504 G_CALLBACK (menuitem_destroy_callback
),
2507 /* Put cb_data in widget, so we can get at it when modifying menubar */
2508 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2510 /* final item, not a submenu */
2511 if (item
->call_data
&& ! item
->contents
)
2515 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2521 /* Create a full menu tree specified by DATA.
2522 F is the frame the created menu belongs to.
2523 SELECT_CB is the callback to use when a menu item is selected.
2524 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2525 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2526 If POP_UP_P, create a popup menu.
2527 If MENU_BAR_P, create a menu bar.
2528 If ADD_TEAROFF_P, add a tearoff menu item. Ignored if MENU_BAR_P or
2529 the Gtk+ version used does not have tearoffs.
2530 TOPMENU is the topmost GtkWidget that others shall be placed under.
2531 It may be NULL, in that case we create the appropriate widget
2532 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2533 CL_DATA is the callback data we shall use for this menu, or NULL
2534 if we haven't set the first callback yet.
2535 NAME is the name to give to the top level menu if this function
2536 creates it. May be NULL to not set any name.
2538 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2541 This function calls itself to create submenus. */
2544 create_menus (widget_value
*data
,
2546 GCallback select_cb
,
2547 GCallback deactivate_cb
,
2548 GCallback highlight_cb
,
2553 xg_menu_cb_data
*cl_data
,
2557 GtkWidget
*wmenu
= topmenu
;
2558 GSList
*group
= NULL
;
2564 wmenu
= gtk_menu_new ();
2565 xg_set_screen (wmenu
, f
);
2566 /* Connect this to the menu instead of items so we get enter/leave for
2567 disabled items also. TODO: Still does not get enter/leave for
2568 disabled items in detached menus. */
2569 g_signal_connect (G_OBJECT (wmenu
),
2570 "enter-notify-event",
2571 G_CALLBACK (menuitem_highlight_callback
),
2573 g_signal_connect (G_OBJECT (wmenu
),
2574 "leave-notify-event",
2575 G_CALLBACK (menuitem_highlight_callback
),
2580 wmenu
= gtk_menu_bar_new ();
2581 /* Set width of menu bar to a small value so it doesn't enlarge
2582 a small initial frame size. The width will be set to the
2583 width of the frame later on when it is added to a container.
2584 height -1: Natural height. */
2585 gtk_widget_set_size_request (wmenu
, 1, -1);
2588 /* Put cl_data on the top menu for easier access. */
2589 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2590 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2591 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2592 G_CALLBACK (menu_destroy_callback
), cl_data
);
2595 gtk_widget_set_name (wmenu
, name
);
2598 g_signal_connect (G_OBJECT (wmenu
),
2599 "selection-done", deactivate_cb
, 0);
2602 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
2603 if (! menu_bar_p
&& add_tearoff_p
)
2605 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2606 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2608 g_signal_connect (G_OBJECT (tearoff
), "activate",
2609 G_CALLBACK (tearoff_activate
), 0);
2613 for (item
= data
; item
; item
= item
->next
)
2617 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2618 && !menu_separator_name_p (item
->name
))
2621 /* A title for a popup. We do the same as GTK does when
2622 creating titles, but it does not look good. */
2624 utf8_label
= get_utf8_string (item
->name
);
2626 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
2627 w
= gtk_menu_item_new_with_label (utf8_label
);
2628 gtk_widget_set_sensitive (w
, FALSE
);
2629 if (utf8_label
) g_free (utf8_label
);
2631 else if (menu_separator_name_p (item
->name
))
2634 /* GTK only have one separator type. */
2635 w
= gtk_separator_menu_item_new ();
2639 w
= xg_create_one_menuitem (item
,
2641 item
->contents
? 0 : select_cb
,
2646 /* Create a possibly empty submenu for menu bar items, since some
2647 themes don't highlight items correctly without it. */
2648 if (item
->contents
|| menu_bar_p
)
2650 GtkWidget
*submenu
= create_menus (item
->contents
,
2661 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2665 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2666 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2672 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2673 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2674 with some text and buttons.
2675 F is the frame the created item belongs to.
2676 NAME is the name to use for the top widget.
2677 VAL is a widget_value structure describing items to be created.
2678 SELECT_CB is the callback to use when a menu item is selected or
2679 a dialog button is pressed.
2680 DEACTIVATE_CB is the callback to use when an item is deactivated.
2681 For a menu, when a sub menu is not shown anymore, for a dialog it is
2682 called when the dialog is popped down.
2683 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2685 Returns the widget created. */
2688 xg_create_widget (const char *type
, const char *name
, struct frame
*f
,
2689 widget_value
*val
, GCallback select_cb
,
2690 GCallback deactivate_cb
, GCallback highlight_cb
)
2693 bool menu_bar_p
= strcmp (type
, "menubar") == 0;
2694 bool pop_up_p
= strcmp (type
, "popup") == 0;
2696 if (strcmp (type
, "dialog") == 0)
2698 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2699 xg_set_screen (w
, f
);
2700 gtk_window_set_transient_for (GTK_WINDOW (w
),
2701 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2702 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2703 gtk_widget_set_name (w
, "emacs-dialog");
2704 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2706 else if (menu_bar_p
|| pop_up_p
)
2708 w
= create_menus (val
->contents
,
2720 /* Set the cursor to an arrow for popup menus when they are mapped.
2721 This is done by default for menu bar menus. */
2724 /* Must realize so the GdkWindow inside the widget is created. */
2725 gtk_widget_realize (w
);
2726 xg_set_cursor (w
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
2731 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2738 /* Return the label for menu item WITEM. */
2741 xg_get_menu_item_label (GtkMenuItem
*witem
)
2743 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2744 return gtk_label_get_label (wlabel
);
2747 /* Return true if the menu item WITEM has the text LABEL. */
2750 xg_item_label_same_p (GtkMenuItem
*witem
, const char *label
)
2753 char *utf8_label
= get_utf8_string (label
);
2754 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2756 if (! old_label
&& ! utf8_label
)
2758 else if (old_label
&& utf8_label
)
2759 is_same
= strcmp (utf8_label
, old_label
) == 0;
2761 if (utf8_label
) g_free (utf8_label
);
2766 /* Destroy widgets in LIST. */
2769 xg_destroy_widgets (GList
*list
)
2773 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2775 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2777 /* Destroying the widget will remove it from the container it is in. */
2778 gtk_widget_destroy (w
);
2782 /* Update the top level names in MENUBAR (i.e. not submenus).
2783 F is the frame the menu bar belongs to.
2784 *LIST is a list with the current menu bar names (menu item widgets).
2785 ITER is the item within *LIST that shall be updated.
2786 POS is the numerical position, starting at 0, of ITER in *LIST.
2787 VAL describes what the menu bar shall look like after the update.
2788 SELECT_CB is the callback to use when a menu item is selected.
2789 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2790 CL_DATA points to the callback data to be used for this menu bar.
2792 This function calls itself to walk through the menu bar names. */
2795 xg_update_menubar (GtkWidget
*menubar
,
2801 GCallback select_cb
,
2802 GCallback deactivate_cb
,
2803 GCallback highlight_cb
,
2804 xg_menu_cb_data
*cl_data
)
2806 if (! iter
&& ! val
)
2808 else if (iter
&& ! val
)
2810 /* Item(s) have been removed. Remove all remaining items. */
2811 xg_destroy_widgets (iter
);
2813 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2814 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2815 gtk_menu_item_new_with_label (""),
2821 else if (! iter
&& val
)
2823 /* Item(s) added. Add all new items in one call. */
2824 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2825 0, 1, 0, menubar
, cl_data
, 0);
2831 /* Below this neither iter or val is NULL */
2832 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2834 /* This item is still the same, check next item. */
2836 iter
= g_list_next (iter
);
2839 else /* This item is changed. */
2841 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2842 GtkMenuItem
*witem2
= 0;
2843 bool val_in_menubar
= 0;
2844 bool iter_in_new_menubar
= 0;
2848 /* See if the changed entry (val) is present later in the menu bar */
2850 iter2
&& ! val_in_menubar
;
2851 iter2
= g_list_next (iter2
))
2853 witem2
= GTK_MENU_ITEM (iter2
->data
);
2854 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2857 /* See if the current entry (iter) is present later in the
2858 specification for the new menu bar. */
2859 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2860 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2862 if (val_in_menubar
&& ! iter_in_new_menubar
)
2866 /* This corresponds to:
2871 g_object_ref (G_OBJECT (witem
));
2872 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2873 gtk_widget_destroy (GTK_WIDGET (witem
));
2875 /* Must get new list since the old changed. */
2876 g_list_free (*list
);
2877 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2878 while (nr
-- > 0) iter
= g_list_next (iter
);
2880 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2882 /* This corresponds to:
2885 Rename B to X. This might seem to be a strange thing to do,
2886 since if there is a menu under B it will be totally wrong for X.
2887 But consider editing a C file. Then there is a C-mode menu
2888 (corresponds to B above).
2889 If then doing C-x C-f the minibuf menu (X above) replaces the
2890 C-mode menu. When returning from the minibuffer, we get
2891 back the C-mode menu. Thus we do:
2892 Rename B to X (C-mode to minibuf menu)
2893 Rename X to B (minibuf to C-mode menu).
2894 If the X menu hasn't been invoked, the menu under B
2895 is up to date when leaving the minibuffer. */
2896 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2897 char *utf8_label
= get_utf8_string (val
->name
);
2898 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2900 gtk_label_set_text (wlabel
, utf8_label
);
2902 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
2903 /* If this item has a submenu that has been detached, change
2904 the title in the WM decorations also. */
2905 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2906 /* Set the title of the detached window. */
2907 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2910 if (utf8_label
) g_free (utf8_label
);
2911 iter
= g_list_next (iter
);
2915 else if (! val_in_menubar
&& iter_in_new_menubar
)
2917 /* This corresponds to:
2924 GtkWidget
*w
= xg_create_one_menuitem (val
,
2931 /* Create a possibly empty submenu for menu bar items, since some
2932 themes don't highlight items correctly without it. */
2933 GtkWidget
*submenu
= create_menus (NULL
, f
,
2934 select_cb
, deactivate_cb
,
2936 0, 0, 0, 0, cl_data
, 0);
2937 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2938 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2939 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2941 g_list_free (*list
);
2942 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2943 while (nr
-- > 0) iter
= g_list_next (iter
);
2944 iter
= g_list_next (iter
);
2948 else /* if (val_in_menubar && iter_in_new_menubar) */
2951 /* This corresponds to:
2956 g_object_ref (G_OBJECT (witem2
));
2957 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2958 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2959 GTK_WIDGET (witem2
), pos
);
2960 g_object_unref (G_OBJECT (witem2
));
2962 g_list_free (*list
);
2963 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2964 while (nr
-- > 0) iter
= g_list_next (iter
);
2965 if (iter
) iter
= g_list_next (iter
);
2971 /* Update the rest of the menu bar. */
2972 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2973 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2976 /* Update the menu item W so it corresponds to VAL.
2977 SELECT_CB is the callback to use when a menu item is selected.
2978 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2979 CL_DATA is the data to set in the widget for menu invocation. */
2982 xg_update_menu_item (widget_value
*val
,
2984 GCallback select_cb
,
2985 GCallback highlight_cb
,
2986 xg_menu_cb_data
*cl_data
)
2993 const char *old_label
= 0;
2994 const char *old_key
= 0;
2995 xg_menu_item_cb_data
*cb_data
;
2997 wchild
= XG_BIN_CHILD (w
);
2998 utf8_label
= get_utf8_string (val
->name
);
2999 utf8_key
= get_utf8_string (val
->key
);
3001 /* See if W is a menu item with a key. See make_menu_item above. */
3002 if (GTK_IS_BOX (wchild
))
3004 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
3006 wlbl
= GTK_LABEL (list
->data
);
3007 wkey
= GTK_LABEL (list
->next
->data
);
3012 /* Remove the key and keep just the label. */
3013 g_object_ref (G_OBJECT (wlbl
));
3014 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
3015 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
3016 g_object_unref (G_OBJECT (wlbl
));
3021 else /* Just a label. */
3023 wlbl
= GTK_LABEL (wchild
);
3025 /* Check if there is now a key. */
3028 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
3029 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
3031 wlbl
= GTK_LABEL (list
->data
);
3032 wkey
= GTK_LABEL (list
->next
->data
);
3035 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
3036 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
3041 if (wkey
) old_key
= gtk_label_get_label (wkey
);
3042 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
3044 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
3045 gtk_label_set_text (wkey
, utf8_key
);
3047 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
3048 gtk_label_set_text (wlbl
, utf8_label
);
3050 if (utf8_key
) g_free (utf8_key
);
3051 if (utf8_label
) g_free (utf8_label
);
3053 if (! val
->enabled
&& gtk_widget_get_sensitive (w
))
3054 gtk_widget_set_sensitive (w
, FALSE
);
3055 else if (val
->enabled
&& ! gtk_widget_get_sensitive (w
))
3056 gtk_widget_set_sensitive (w
, TRUE
);
3058 cb_data
= g_object_get_data (G_OBJECT (w
), XG_ITEM_DATA
);
3061 cb_data
->call_data
= val
->call_data
;
3062 cb_data
->help
= val
->help
;
3063 cb_data
->cl_data
= cl_data
;
3065 /* We assume the callback functions don't change. */
3066 if (val
->call_data
&& ! val
->contents
)
3068 /* This item shall have a select callback. */
3069 if (! cb_data
->select_id
)
3071 = g_signal_connect (G_OBJECT (w
), "activate",
3072 select_cb
, cb_data
);
3074 else if (cb_data
->select_id
)
3076 g_signal_handler_disconnect (w
, cb_data
->select_id
);
3077 cb_data
->select_id
= 0;
3082 /* Update the toggle menu item W so it corresponds to VAL. */
3085 xg_update_toggle_item (widget_value
*val
, GtkWidget
*w
)
3087 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3090 /* Update the radio menu item W so it corresponds to VAL. */
3093 xg_update_radio_item (widget_value
*val
, GtkWidget
*w
)
3095 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3098 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
3099 SUBMENU may be NULL, in that case a new menu is created.
3100 F is the frame the menu bar belongs to.
3101 VAL describes the contents of the menu bar.
3102 SELECT_CB is the callback to use when a menu item is selected.
3103 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3104 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
3105 CL_DATA is the call back data to use for any newly created items.
3107 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
3111 xg_update_submenu (GtkWidget
*submenu
,
3114 GCallback select_cb
,
3115 GCallback deactivate_cb
,
3116 GCallback highlight_cb
,
3117 xg_menu_cb_data
*cl_data
)
3119 GtkWidget
*newsub
= submenu
;
3123 bool has_tearoff_p
= 0;
3124 GList
*first_radio
= 0;
3127 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
3129 for (cur
= val
, iter
= list
;
3131 iter
= g_list_next (iter
), cur
= cur
->next
)
3133 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3135 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
3136 /* Skip tearoff items, they have no counterpart in val. */
3137 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
3140 iter
= g_list_next (iter
);
3141 if (iter
) w
= GTK_WIDGET (iter
->data
);
3146 /* Remember first radio button in a group. If we get a mismatch in
3147 a radio group we must rebuild the whole group so that the connections
3148 in GTK becomes correct. */
3149 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
3151 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
3152 && ! GTK_IS_RADIO_MENU_ITEM (w
))
3155 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
3157 if (! menu_separator_name_p (cur
->name
))
3160 else if (GTK_IS_CHECK_MENU_ITEM (w
))
3162 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
3164 xg_update_toggle_item (cur
, w
);
3165 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3167 else if (GTK_IS_RADIO_MENU_ITEM (w
))
3169 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
3171 xg_update_radio_item (cur
, w
);
3172 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3174 else if (GTK_IS_MENU_ITEM (w
))
3176 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
3179 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
3180 menu_separator_name_p (cur
->name
))
3183 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3185 sub
= gtk_menu_item_get_submenu (witem
);
3186 if (sub
&& ! cur
->contents
)
3188 /* Not a submenu anymore. */
3189 g_object_ref (G_OBJECT (sub
));
3190 remove_submenu (witem
);
3191 gtk_widget_destroy (sub
);
3193 else if (cur
->contents
)
3197 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
3198 select_cb
, deactivate_cb
,
3199 highlight_cb
, cl_data
);
3201 /* If this item just became a submenu, we must set it. */
3203 gtk_menu_item_set_submenu (witem
, nsub
);
3208 /* Structural difference. Remove everything from here and down
3214 /* Remove widgets from first structural change. */
3217 /* If we are adding new menu items below, we must remove from
3218 first radio button so that radio groups become correct. */
3219 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
3220 else xg_destroy_widgets (iter
);
3225 /* More items added. Create them. */
3226 newsub
= create_menus (cur
,
3239 if (list
) g_list_free (list
);
3244 /* Update the MENUBAR.
3245 F is the frame the menu bar belongs to.
3246 VAL describes the contents of the menu bar.
3247 If DEEP_P, rebuild all but the top level menu names in
3248 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
3249 SELECT_CB is the callback to use when a menu item is selected.
3250 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3251 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
3254 xg_modify_menubar_widgets (GtkWidget
*menubar
, struct frame
*f
,
3255 widget_value
*val
, bool deep_p
,
3256 GCallback select_cb
, GCallback deactivate_cb
,
3257 GCallback highlight_cb
)
3259 xg_menu_cb_data
*cl_data
;
3260 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
3264 cl_data
= g_object_get_data (G_OBJECT (menubar
), XG_FRAME_DATA
);
3266 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
3267 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
3273 /* Update all sub menus.
3274 We must keep the submenus (GTK menu item widgets) since the
3275 X Window in the XEvent that activates the menu are those widgets. */
3277 /* Update cl_data, menu_item things in F may have changed. */
3278 update_cl_data (cl_data
, f
, highlight_cb
);
3280 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
3285 GtkMenuItem
*witem
= 0;
3287 /* Find sub menu that corresponds to val and update it. */
3288 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3290 witem
= GTK_MENU_ITEM (iter
->data
);
3291 if (xg_item_label_same_p (witem
, cur
->name
))
3293 sub
= gtk_menu_item_get_submenu (witem
);
3298 newsub
= xg_update_submenu (sub
,
3305 /* sub may still be NULL. If we just updated non deep and added
3306 a new menu bar item, it has no sub menu yet. So we set the
3307 newly created sub menu under witem. */
3308 if (newsub
!= sub
&& witem
!= 0)
3310 xg_set_screen (newsub
, f
);
3311 gtk_menu_item_set_submenu (witem
, newsub
);
3317 gtk_widget_show_all (menubar
);
3320 /* Callback called when the menu bar W is mapped.
3321 Used to find the height of the menu bar if we didn't get it
3322 after showing the widget. */
3325 menubar_map_cb (GtkWidget
*w
, gpointer user_data
)
3328 struct frame
*f
= user_data
;
3329 gtk_widget_get_preferred_size (w
, NULL
, &req
);
3330 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3332 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3333 xg_height_or_width_changed (f
);
3337 /* Recompute all the widgets of frame F, when the menu bar has been
3341 xg_update_frame_menubar (struct frame
*f
)
3343 struct x_output
*x
= f
->output_data
.x
;
3346 if (!x
->menubar_widget
|| gtk_widget_get_mapped (x
->menubar_widget
))
3349 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
3350 return; /* Already done this, happens for frames created invisible. */
3354 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
3356 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
3358 g_signal_connect (x
->menubar_widget
, "map", G_CALLBACK (menubar_map_cb
), f
);
3359 gtk_widget_show_all (x
->menubar_widget
);
3360 gtk_widget_get_preferred_size (x
->menubar_widget
, NULL
, &req
);
3362 /* If menu bar doesn't know its height yet, cheat a little so the frame
3363 doesn't jump so much when resized later in menubar_map_cb. */
3364 if (req
.height
== 0)
3367 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3369 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3370 xg_height_or_width_changed (f
);
3375 /* Get rid of the menu bar of frame F, and free its storage.
3376 This is used when deleting a frame, and when turning off the menu bar. */
3379 free_frame_menubar (struct frame
*f
)
3381 struct x_output
*x
= f
->output_data
.x
;
3383 if (x
->menubar_widget
)
3387 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
3388 /* The menubar and its children shall be deleted when removed from
3390 x
->menubar_widget
= 0;
3391 FRAME_MENUBAR_HEIGHT (f
) = 0;
3392 xg_height_or_width_changed (f
);
3398 xg_event_is_for_menubar (struct frame
*f
, const XEvent
*event
)
3400 struct x_output
*x
= f
->output_data
.x
;
3409 if (! x
->menubar_widget
) return 0;
3411 if (! (event
->xbutton
.x
>= 0
3412 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
3413 && event
->xbutton
.y
>= 0
3414 && event
->xbutton
.y
< f
->output_data
.x
->menubar_height
3415 && event
->xbutton
.same_screen
))
3418 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3419 gw
= gdk_x11_window_lookup_for_display (gdpy
, event
->xbutton
.window
);
3421 gevent
.any
.window
= gw
;
3422 gevent
.any
.type
= GDK_NOTHING
;
3423 gwdesc
= gtk_get_event_widget (&gevent
);
3424 if (! gwdesc
) return 0;
3425 if (! GTK_IS_MENU_BAR (gwdesc
)
3426 && ! GTK_IS_MENU_ITEM (gwdesc
)
3427 && ! gtk_widget_is_ancestor (x
->menubar_widget
, gwdesc
))
3430 list
= gtk_container_get_children (GTK_CONTAINER (x
->menubar_widget
));
3431 if (! list
) return 0;
3432 rec
.x
= event
->xbutton
.x
;
3433 rec
.y
= event
->xbutton
.y
;
3437 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3439 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3440 if (gtk_widget_get_mapped (w
) && gtk_widget_intersect (w
, &rec
, NULL
))
3449 /***********************************************************************
3450 Scroll bar functions
3451 ***********************************************************************/
3454 /* Setting scroll bar values invokes the callback. Use this variable
3455 to indicate that callback should do nothing. */
3457 bool xg_ignore_gtk_scrollbar
;
3459 /* The width of the scroll bar for the current theme. */
3461 static int scroll_bar_width_for_theme
;
3463 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
3464 may be larger than 32 bits. Keep a mapping from integer index to widget
3465 pointers to get around the 32 bit limitation. */
3469 GtkWidget
**widgets
;
3474 /* Grow this much every time we need to allocate more */
3476 #define ID_TO_WIDGET_INCR 32
3478 /* Store the widget pointer W in id_to_widget and return the integer index. */
3481 xg_store_widget_in_map (GtkWidget
*w
)
3485 if (id_to_widget
.max_size
== id_to_widget
.used
)
3488 if (TYPE_MAXIMUM (Window
) - ID_TO_WIDGET_INCR
< id_to_widget
.max_size
)
3489 memory_full (SIZE_MAX
);
3491 new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
3492 id_to_widget
.widgets
= xnrealloc (id_to_widget
.widgets
,
3493 new_size
, sizeof (GtkWidget
*));
3495 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
3496 id_to_widget
.widgets
[i
] = 0;
3497 id_to_widget
.max_size
= new_size
;
3500 /* Just loop over the array and find a free place. After all,
3501 how many scroll bars are we creating? Should be a small number.
3502 The check above guarantees we will find a free place. */
3503 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
3505 if (! id_to_widget
.widgets
[i
])
3507 id_to_widget
.widgets
[i
] = w
;
3508 ++id_to_widget
.used
;
3514 /* Should never end up here */
3518 /* Remove pointer at IDX from id_to_widget.
3519 Called when scroll bar is destroyed. */
3522 xg_remove_widget_from_map (ptrdiff_t idx
)
3524 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3526 id_to_widget
.widgets
[idx
] = 0;
3527 --id_to_widget
.used
;
3531 /* Get the widget pointer at IDX from id_to_widget. */
3534 xg_get_widget_from_map (ptrdiff_t idx
)
3536 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3537 return id_to_widget
.widgets
[idx
];
3543 update_theme_scrollbar_width (void)
3546 GtkAdjustment
*vadj
;
3553 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
, 0.1, 0.1, 0.1);
3554 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3555 g_object_ref_sink (G_OBJECT (wscroll
));
3556 gtk_widget_style_get (wscroll
, "slider-width", &w
, "trough-border", &b
, NULL
);
3557 gtk_widget_destroy (wscroll
);
3558 g_object_unref (G_OBJECT (wscroll
));
3561 scroll_bar_width_for_theme
= w
;
3565 xg_get_default_scrollbar_width (void)
3567 return scroll_bar_width_for_theme
;
3570 /* Return the scrollbar id for X Window WID on display DPY.
3571 Return -1 if WID not in id_to_widget. */
3574 xg_get_scroll_id_for_window (Display
*dpy
, Window wid
)
3579 w
= xg_win_to_widget (dpy
, wid
);
3583 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3584 if (id_to_widget
.widgets
[idx
] == w
)
3591 /* Callback invoked when scroll bar WIDGET is destroyed.
3592 DATA is the index into id_to_widget for WIDGET.
3593 We free pointer to last scroll bar values here and remove the index. */
3596 xg_gtk_scroll_destroy (GtkWidget
*widget
, gpointer data
)
3598 intptr_t id
= (intptr_t) data
;
3599 xg_remove_widget_from_map (id
);
3602 /* Create a scroll bar widget for frame F. Store the scroll bar
3604 SCROLL_CALLBACK is the callback to invoke when the value of the
3606 END_CALLBACK is the callback to invoke when scrolling ends.
3607 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3608 to set resources for the widget. */
3611 xg_create_scroll_bar (struct frame
*f
,
3612 struct scroll_bar
*bar
,
3613 GCallback scroll_callback
,
3614 GCallback end_callback
,
3615 const char *scroll_bar_name
)
3621 GtkAdjustment
*vadj
;
3626 /* Page, step increment values are not so important here, they
3627 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3628 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3631 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3632 webox
= gtk_event_box_new ();
3633 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3635 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3637 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3639 scroll_id
= xg_store_widget_in_map (wscroll
);
3641 g_signal_connect (G_OBJECT (wscroll
),
3643 G_CALLBACK (xg_gtk_scroll_destroy
),
3644 (gpointer
) scroll_id
);
3645 g_signal_connect (G_OBJECT (wscroll
),
3649 g_signal_connect (G_OBJECT (wscroll
),
3650 "button-release-event",
3654 /* The scroll bar widget does not draw on a window of its own. Instead
3655 it draws on the parent window, in this case the edit widget. So
3656 whenever the edit widget is cleared, the scroll bar needs to redraw
3657 also, which causes flicker. Put an event box between the edit widget
3658 and the scroll bar, so the scroll bar instead draws itself on the
3659 event box window. */
3660 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3661 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3664 /* Set the cursor to an arrow. */
3665 xg_set_cursor (webox
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
3667 bar
->x_window
= scroll_id
;
3670 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3673 xg_remove_scroll_bar (struct frame
*f
, ptrdiff_t scrollbar_id
)
3675 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3678 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3679 gtk_widget_destroy (w
);
3680 gtk_widget_destroy (wparent
);
3681 SET_FRAME_GARBAGED (f
);
3685 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3687 TOP/LEFT are the new pixel positions where the bar shall appear.
3688 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3691 xg_update_scrollbar_pos (struct frame
*f
,
3692 ptrdiff_t scrollbar_id
,
3699 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3703 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3704 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3707 /* Clear out old position. */
3708 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3709 if (gtk_widget_get_parent (wparent
) == wfixed
)
3711 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3712 "x", &oldx
, "y", &oldy
, NULL
);
3713 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3716 /* Move and resize to new values. */
3717 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3718 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3721 /* No room. Hide scroll bar as some themes output a warning if
3722 the height is less than the min size. */
3723 gtk_widget_hide (wparent
);
3724 gtk_widget_hide (wscroll
);
3728 gtk_widget_show_all (wparent
);
3729 gtk_widget_set_size_request (wscroll
, width
, height
);
3731 gtk_widget_queue_draw (wfixed
);
3732 gdk_window_process_all_updates ();
3733 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3734 /* Clear under old scroll bar position. This must be done after
3735 the gtk_widget_queue_draw and gdk_window_process_all_updates
3737 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3738 oldx
, oldy
, oldw
, oldh
);
3740 /* GTK does not redraw until the main loop is entered again, but
3741 if there are no X events pending we will not enter it. So we sync
3742 here to get some events. */
3745 SET_FRAME_GARBAGED (f
);
3746 cancel_mouse_face (f
);
3750 /* Get the current value of the range, truncated to an integer. */
3753 int_gtk_range_get_value (GtkRange
*range
)
3755 return gtk_range_get_value (range
);
3759 /* Set the thumb size and position of scroll bar BAR. We are currently
3760 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3763 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
,
3768 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3770 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3772 if (wscroll
&& bar
->dragging
== -1)
3782 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3784 if (scroll_bar_adjust_thumb_portion_p
)
3786 /* We do the same as for MOTIF in xterm.c, use 30 chars per
3787 line rather than the real portion value. This makes the
3788 thumb less likely to resize and that looks better. */
3789 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3791 /* When the thumb is at the bottom, position == whole.
3792 So we need to increase `whole' to make space for the thumb. */
3800 top
= (gdouble
) position
/ whole
;
3801 shown
= (gdouble
) portion
/ whole
;
3804 size
= clip_to_bounds (1, shown
* XG_SB_RANGE
, XG_SB_RANGE
);
3805 value
= clip_to_bounds (XG_SB_MIN
, top
* XG_SB_RANGE
, XG_SB_MAX
- size
);
3807 /* Assume all lines are of equal size. */
3808 new_step
= size
/ max (1, FRAME_LINES (f
));
3810 old_size
= gtk_adjustment_get_page_size (adj
);
3811 if (old_size
!= size
)
3813 int old_step
= gtk_adjustment_get_step_increment (adj
);
3814 if (old_step
!= new_step
)
3816 gtk_adjustment_set_page_size (adj
, size
);
3817 gtk_adjustment_set_step_increment (adj
, new_step
);
3818 /* Assume a page increment is about 95% of the page size */
3819 gtk_adjustment_set_page_increment (adj
, size
- size
/ 20);
3824 if (changed
|| int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3828 /* gtk_range_set_value invokes the callback. Set
3829 ignore_gtk_scrollbar to make the callback do nothing */
3830 xg_ignore_gtk_scrollbar
= 1;
3832 if (int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3833 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3835 gtk_adjustment_changed (adj
);
3837 xg_ignore_gtk_scrollbar
= 0;
3844 /* Return true if EVENT is for a scroll bar in frame F.
3845 When the same X window is used for several Gtk+ widgets, we cannot
3846 say for sure based on the X window alone if an event is for the
3847 frame. This function does additional checks. */
3850 xg_event_is_for_scrollbar (struct frame
*f
, const XEvent
*event
)
3854 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
3856 /* Check if press occurred outside the edit widget. */
3857 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3860 GdkDevice
*gdev
= gdk_device_manager_get_client_pointer
3861 (gdk_display_get_device_manager (gdpy
));
3862 gwin
= gdk_device_get_window_at_position (gdev
, NULL
, NULL
);
3864 gwin
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
);
3866 retval
= gwin
!= gtk_widget_get_window (f
->output_data
.x
->edit_widget
);
3869 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
3870 || event
->type
== MotionNotify
))
3872 /* If we are releasing or moving the scroll bar, it has the grab. */
3873 GtkWidget
*w
= gtk_grab_get_current ();
3874 retval
= w
!= 0 && GTK_IS_SCROLLBAR (w
);
3882 /***********************************************************************
3884 ***********************************************************************/
3885 /* The key for the data we put in the GtkImage widgets. The data is
3886 the image used by Emacs. We use this to see if we need to update
3887 the GtkImage with a new image. */
3888 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3890 /* The key for storing the latest modifiers so the activate callback can
3892 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
3894 /* The key for storing the button widget in its proxy menu item. */
3895 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
3897 /* The key for the data we put in the GtkImage widgets. The data is
3898 the stock name used by Emacs. We use this to see if we need to update
3899 the GtkImage with a new image. */
3900 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
3902 /* As above, but this is used for named theme widgets, as opposed to
3904 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
3906 /* Callback function invoked when a tool bar item is pressed.
3907 W is the button widget in the tool bar that got pressed,
3908 CLIENT_DATA is an integer that is the index of the button in the
3909 tool bar. 0 is the first button. */
3912 xg_tool_bar_button_cb (GtkWidget
*widget
,
3913 GdkEventButton
*event
,
3916 intptr_t state
= event
->state
;
3917 gpointer ptr
= (gpointer
) state
;
3918 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
3923 /* Callback function invoked when a tool bar item is pressed.
3924 W is the button widget in the tool bar that got pressed,
3925 CLIENT_DATA is an integer that is the index of the button in the
3926 tool bar. 0 is the first button. */
3929 xg_tool_bar_callback (GtkWidget
*w
, gpointer client_data
)
3931 intptr_t idx
= (intptr_t) client_data
;
3932 gpointer gmod
= g_object_get_data (G_OBJECT (w
), XG_TOOL_BAR_LAST_MODIFIER
);
3933 intptr_t mod
= (intptr_t) gmod
;
3935 struct frame
*f
= g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3936 Lisp_Object key
, frame
;
3937 struct input_event event
;
3940 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3943 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3945 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3946 XSETFRAME (frame
, f
);
3948 /* We generate two events here. The first one is to set the prefix
3949 to `(tool_bar)', see keyboard.c. */
3950 event
.kind
= TOOL_BAR_EVENT
;
3951 event
.frame_or_window
= frame
;
3953 kbd_buffer_store_event (&event
);
3955 event
.kind
= TOOL_BAR_EVENT
;
3956 event
.frame_or_window
= frame
;
3958 /* Convert between the modifier bits GDK uses and the modifier bits
3959 Emacs uses. This assumes GDK and X masks are the same, which they are when
3961 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO (f
), mod
);
3962 kbd_buffer_store_event (&event
);
3964 /* Return focus to the frame after we have clicked on a detached
3969 /* Callback function invoked when a tool bar item is pressed in a detached
3970 tool bar or the overflow drop down menu.
3971 We just call xg_tool_bar_callback.
3972 W is the menu item widget that got pressed,
3973 CLIENT_DATA is an integer that is the index of the button in the
3974 tool bar. 0 is the first button. */
3977 xg_tool_bar_proxy_callback (GtkWidget
*w
, gpointer client_data
)
3979 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3980 XG_TOOL_BAR_PROXY_BUTTON
));
3981 xg_tool_bar_callback (wbutton
, client_data
);
3986 xg_tool_bar_help_callback (GtkWidget
*w
,
3987 GdkEventCrossing
*event
,
3988 gpointer client_data
);
3990 /* This callback is called when a help is to be shown for an item in
3991 the detached tool bar when the detached tool bar it is not expanded. */
3994 xg_tool_bar_proxy_help_callback (GtkWidget
*w
,
3995 GdkEventCrossing
*event
,
3996 gpointer client_data
)
3998 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3999 XG_TOOL_BAR_PROXY_BUTTON
));
4001 return xg_tool_bar_help_callback (wbutton
, event
, client_data
);
4005 xg_get_tool_bar_widgets (GtkWidget
*vb
, GtkWidget
**wimage
)
4007 GList
*clist
= gtk_container_get_children (GTK_CONTAINER (vb
));
4008 GtkWidget
*c1
= clist
->data
;
4009 GtkWidget
*c2
= clist
->next
? clist
->next
->data
: NULL
;
4011 *wimage
= GTK_IS_IMAGE (c1
) ? c1
: c2
;
4012 g_list_free (clist
);
4013 return GTK_IS_LABEL (c1
) ? c1
: c2
;
4017 /* This callback is called when a tool item should create a proxy item,
4018 such as for the overflow menu. Also called when the tool bar is detached.
4019 If we don't create a proxy menu item, the detached tool bar will be
4023 xg_tool_bar_menu_proxy (GtkToolItem
*toolitem
, gpointer user_data
)
4025 GtkButton
*wbutton
= GTK_BUTTON (XG_BIN_CHILD (XG_BIN_CHILD (toolitem
)));
4026 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4028 GtkLabel
*wlbl
= GTK_LABEL (xg_get_tool_bar_widgets (vb
, &c1
));
4029 GtkImage
*wimage
= GTK_IMAGE (c1
);
4030 GtkWidget
*wmenuitem
= gtk_image_menu_item_new_with_label
4031 (wlbl
? gtk_label_get_text (wlbl
) : "");
4032 GtkWidget
*wmenuimage
;
4035 if (gtk_button_get_use_stock (wbutton
))
4036 wmenuimage
= gtk_image_new_from_stock (gtk_button_get_label (wbutton
),
4037 GTK_ICON_SIZE_MENU
);
4040 GtkSettings
*settings
= gtk_widget_get_settings (GTK_WIDGET (wbutton
));
4041 GtkImageType store_type
= gtk_image_get_storage_type (wimage
);
4043 g_object_set (G_OBJECT (settings
), "gtk-menu-images", TRUE
, NULL
);
4045 if (store_type
== GTK_IMAGE_STOCK
)
4048 gtk_image_get_stock (wimage
, &stock_id
, NULL
);
4049 wmenuimage
= gtk_image_new_from_stock (stock_id
, GTK_ICON_SIZE_MENU
);
4051 else if (store_type
== GTK_IMAGE_ICON_SET
)
4053 GtkIconSet
*icon_set
;
4054 gtk_image_get_icon_set (wimage
, &icon_set
, NULL
);
4055 wmenuimage
= gtk_image_new_from_icon_set (icon_set
,
4056 GTK_ICON_SIZE_MENU
);
4058 else if (store_type
== GTK_IMAGE_PIXBUF
)
4063 gtk_icon_size_lookup_for_settings (settings
, GTK_ICON_SIZE_MENU
,
4066 GdkPixbuf
*src_pixbuf
, *dest_pixbuf
;
4068 src_pixbuf
= gtk_image_get_pixbuf (wimage
);
4069 dest_pixbuf
= gdk_pixbuf_scale_simple (src_pixbuf
, width
, height
,
4070 GDK_INTERP_BILINEAR
);
4072 wmenuimage
= gtk_image_new_from_pixbuf (dest_pixbuf
);
4076 fprintf (stderr
, "internal error: GTK_IMAGE_PIXBUF failed\n");
4080 else if (store_type
== GTK_IMAGE_ICON_NAME
)
4082 const gchar
*icon_name
;
4083 GtkIconSize icon_size
;
4085 gtk_image_get_icon_name (wimage
, &icon_name
, &icon_size
);
4086 wmenuimage
= gtk_image_new_from_icon_name (icon_name
,
4087 GTK_ICON_SIZE_MENU
);
4091 fprintf (stderr
, "internal error: store_type is %d\n", store_type
);
4096 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem
), wmenuimage
);
4098 g_signal_connect (G_OBJECT (wmenuitem
),
4100 G_CALLBACK (xg_tool_bar_proxy_callback
),
4104 g_object_set_data (G_OBJECT (wmenuitem
), XG_TOOL_BAR_PROXY_BUTTON
,
4105 (gpointer
) wbutton
);
4106 gtk_tool_item_set_proxy_menu_item (toolitem
, "Emacs toolbar item", wmenuitem
);
4107 gtk_widget_set_sensitive (wmenuitem
,
4108 gtk_widget_get_sensitive (GTK_WIDGET (wbutton
)));
4110 /* Use enter/leave notify to show help. We use the events
4111 rather than the GtkButton specific signals "enter" and
4112 "leave", so we can have only one callback. The event
4113 will tell us what kind of event it is. */
4114 g_signal_connect (G_OBJECT (wmenuitem
),
4115 "enter-notify-event",
4116 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
4118 g_signal_connect (G_OBJECT (wmenuitem
),
4119 "leave-notify-event",
4120 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
4126 /* This callback is called when a tool bar is detached. We must set
4127 the height of the tool bar to zero when this happens so frame sizes
4128 are correctly calculated.
4129 WBOX is the handle box widget that enables detach/attach of the tool bar.
4130 W is the tool bar widget.
4131 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
4134 xg_tool_bar_detach_callback (GtkHandleBox
*wbox
,
4136 gpointer client_data
)
4138 struct frame
*f
= client_data
;
4140 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
4145 GtkRequisition req
, req2
;
4147 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
4148 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
4149 req
.width
-= req2
.width
;
4150 req
.height
-= req2
.height
;
4151 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
4152 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
4153 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
4154 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
4155 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
4156 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
4157 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
4158 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
4159 xg_height_or_width_changed (f
);
4163 /* This callback is called when a tool bar is reattached. We must set
4164 the height of the tool bar when this happens so frame sizes
4165 are correctly calculated.
4166 WBOX is the handle box widget that enables detach/attach of the tool bar.
4167 W is the tool bar widget.
4168 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
4171 xg_tool_bar_attach_callback (GtkHandleBox
*wbox
,
4173 gpointer client_data
)
4175 struct frame
*f
= client_data
;
4176 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
4180 GtkRequisition req
, req2
;
4182 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
4183 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
4184 req
.width
+= req2
.width
;
4185 req
.height
+= req2
.height
;
4186 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
4187 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
4188 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
4189 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
4190 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
4191 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
4192 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
4193 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
4194 xg_height_or_width_changed (f
);
4198 /* This callback is called when the mouse enters or leaves a tool bar item.
4199 It is used for displaying and hiding the help text.
4200 W is the tool bar item, a button.
4201 EVENT is either an enter event or leave event.
4202 CLIENT_DATA is an integer that is the index of the button in the
4203 tool bar. 0 is the first button.
4205 Returns FALSE to tell GTK to keep processing this event. */
4208 xg_tool_bar_help_callback (GtkWidget
*w
,
4209 GdkEventCrossing
*event
,
4210 gpointer client_data
)
4212 intptr_t idx
= (intptr_t) client_data
;
4213 struct frame
*f
= g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
4214 Lisp_Object help
, frame
;
4216 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
4219 if (event
->type
== GDK_ENTER_NOTIFY
)
4221 idx
*= TOOL_BAR_ITEM_NSLOTS
;
4222 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
4225 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
4230 XSETFRAME (frame
, f
);
4231 kbd_buffer_store_help_event (frame
, help
);
4237 /* This callback is called when a tool bar item shall be redrawn.
4238 It modifies the expose event so that the GtkImage widget redraws the
4239 whole image. This to overcome a bug that makes GtkImage draw the image
4240 in the wrong place when it tries to redraw just a part of the image.
4241 W is the GtkImage to be redrawn.
4242 EVENT is the expose event for W.
4243 CLIENT_DATA is unused.
4245 Returns FALSE to tell GTK to keep processing this event. */
4249 xg_tool_bar_item_expose_callback (GtkWidget
*w
,
4250 GdkEventExpose
*event
,
4251 gpointer client_data
)
4255 gdk_drawable_get_size (event
->window
, &width
, &height
);
4256 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
4257 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
4259 event
->area
.x
= max (0, event
->area
.x
);
4260 event
->area
.y
= max (0, event
->area
.y
);
4262 event
->area
.width
= max (width
, event
->area
.width
);
4263 event
->area
.height
= max (height
, event
->area
.height
);
4269 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
4270 #define toolbar_set_orientation(w, o) \
4271 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
4273 #define toolbar_set_orientation(w, o) \
4274 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
4277 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4278 #define TOOLBAR_TOP_WIDGET(x) ((x)->handlebox_widget)
4280 #define TOOLBAR_TOP_WIDGET(x) ((x)->toolbar_widget)
4283 /* Attach a tool bar to frame F. */
4286 xg_pack_tool_bar (struct frame
*f
, Lisp_Object pos
)
4288 struct x_output
*x
= f
->output_data
.x
;
4289 bool into_hbox
= EQ (pos
, Qleft
) || EQ (pos
, Qright
);
4290 GtkWidget
*top_widget
= TOOLBAR_TOP_WIDGET (x
);
4292 toolbar_set_orientation (x
->toolbar_widget
,
4294 ? GTK_ORIENTATION_VERTICAL
4295 : GTK_ORIENTATION_HORIZONTAL
);
4296 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4297 if (!x
->handlebox_widget
)
4299 top_widget
= x
->handlebox_widget
= gtk_handle_box_new ();
4300 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
4301 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
4302 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
4303 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
4304 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
4311 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4312 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4315 gtk_box_pack_start (GTK_BOX (x
->hbox_widget
), top_widget
,
4318 if (EQ (pos
, Qleft
))
4319 gtk_box_reorder_child (GTK_BOX (x
->hbox_widget
),
4322 x
->toolbar_in_hbox
= true;
4326 bool vbox_pos
= x
->menubar_widget
!= 0;
4327 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4328 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4331 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), top_widget
,
4335 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
),
4338 x
->toolbar_in_hbox
= false;
4340 x
->toolbar_is_packed
= true;
4343 static bool xg_update_tool_bar_sizes (struct frame
*f
);
4346 tb_size_cb (GtkWidget
*widget
,
4347 GdkRectangle
*allocation
,
4350 /* When tool bar is created it has one preferred size. But when size is
4351 allocated between widgets, it may get another. So we must update
4352 size hints if tool bar size changes. Seen on Fedora 18 at least. */
4353 struct frame
*f
= user_data
;
4354 if (xg_update_tool_bar_sizes (f
))
4355 xg_height_or_width_changed (f
);
4358 /* Create a tool bar for frame F. */
4361 xg_create_tool_bar (struct frame
*f
)
4363 struct x_output
*x
= f
->output_data
.x
;
4364 #if GTK_CHECK_VERSION (3, 3, 6)
4365 GtkStyleContext
*gsty
;
4367 struct xg_frame_tb_info
*tbinfo
4368 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4372 tbinfo
= xmalloc (sizeof (*tbinfo
));
4373 tbinfo
->last_tool_bar
= Qnil
;
4374 tbinfo
->style
= Qnil
;
4375 tbinfo
->hmargin
= tbinfo
->vmargin
= 0;
4376 tbinfo
->dir
= GTK_TEXT_DIR_NONE
;
4377 tbinfo
->n_last_items
= 0;
4378 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4383 x
->toolbar_widget
= gtk_toolbar_new ();
4385 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
4387 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
4388 toolbar_set_orientation (x
->toolbar_widget
, GTK_ORIENTATION_HORIZONTAL
);
4389 g_signal_connect (x
->toolbar_widget
, "size-allocate",
4390 G_CALLBACK (tb_size_cb
), f
);
4391 #if GTK_CHECK_VERSION (3, 3, 6)
4392 gsty
= gtk_widget_get_style_context (x
->toolbar_widget
);
4393 gtk_style_context_add_class (gsty
, "primary-toolbar");
4398 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
4400 /* Find the right-to-left image named by RTL in the tool bar images for F.
4401 Returns IMAGE if RTL is not found. */
4404 find_rtl_image (struct frame
*f
, Lisp_Object image
, Lisp_Object rtl
)
4407 Lisp_Object file
, rtl_name
;
4408 struct gcpro gcpro1
, gcpro2
;
4409 GCPRO2 (file
, rtl_name
);
4411 rtl_name
= Ffile_name_nondirectory (rtl
);
4413 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
4415 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4416 if (!NILP (file
= file_for_image (rtl_image
)))
4418 file
= call1 (intern ("file-name-sans-extension"),
4419 Ffile_name_nondirectory (file
));
4420 if (! NILP (Fequal (file
, rtl_name
)))
4431 static GtkToolItem
*
4432 xg_make_tool_item (struct frame
*f
,
4434 GtkWidget
**wbutton
,
4436 int i
, bool horiz
, bool text_image
)
4438 GtkToolItem
*ti
= gtk_tool_item_new ();
4439 GtkWidget
*vb
= gtk_box_new (horiz
4440 ? GTK_ORIENTATION_HORIZONTAL
4441 : GTK_ORIENTATION_VERTICAL
,
4443 GtkWidget
*wb
= gtk_button_new ();
4444 /* The eventbox is here so we can have tooltips on disabled items. */
4445 GtkWidget
*weventbox
= gtk_event_box_new ();
4446 #if GTK_CHECK_VERSION (3, 3, 6)
4447 GtkCssProvider
*css_prov
= gtk_css_provider_new ();
4448 GtkStyleContext
*gsty
;
4450 gtk_css_provider_load_from_data (css_prov
,
4452 " background-color: transparent;"
4456 gsty
= gtk_widget_get_style_context (weventbox
);
4457 gtk_style_context_add_provider (gsty
,
4458 GTK_STYLE_PROVIDER (css_prov
),
4459 GTK_STYLE_PROVIDER_PRIORITY_USER
);
4460 g_object_unref (css_prov
);
4463 gtk_box_set_homogeneous (GTK_BOX (vb
), FALSE
);
4465 if (wimage
&& !text_image
)
4466 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4468 gtk_box_pack_start (GTK_BOX (vb
), gtk_label_new (label
), TRUE
, TRUE
, 0);
4469 if (wimage
&& text_image
)
4470 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4472 gtk_button_set_focus_on_click (GTK_BUTTON (wb
), FALSE
);
4473 gtk_button_set_relief (GTK_BUTTON (wb
), GTK_RELIEF_NONE
);
4474 gtk_container_add (GTK_CONTAINER (wb
), vb
);
4475 gtk_container_add (GTK_CONTAINER (weventbox
), wb
);
4476 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
4478 if (wimage
|| label
)
4481 gpointer gi
= (gpointer
) ii
;
4483 g_signal_connect (G_OBJECT (ti
), "create-menu-proxy",
4484 G_CALLBACK (xg_tool_bar_menu_proxy
),
4487 g_signal_connect (G_OBJECT (wb
), "clicked",
4488 G_CALLBACK (xg_tool_bar_callback
),
4491 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
4494 /* Catch expose events to overcome an annoying redraw bug, see
4495 comment for xg_tool_bar_item_expose_callback. */
4496 g_signal_connect (G_OBJECT (ti
),
4498 G_CALLBACK (xg_tool_bar_item_expose_callback
),
4501 gtk_tool_item_set_homogeneous (ti
, FALSE
);
4503 /* Callback to save modifier mask (Shift/Control, etc). GTK makes
4504 no distinction based on modifiers in the activate callback,
4505 so we have to do it ourselves. */
4506 g_signal_connect (wb
, "button-release-event",
4507 G_CALLBACK (xg_tool_bar_button_cb
),
4510 g_object_set_data (G_OBJECT (wb
), XG_FRAME_DATA
, (gpointer
)f
);
4512 /* Use enter/leave notify to show help. We use the events
4513 rather than the GtkButton specific signals "enter" and
4514 "leave", so we can have only one callback. The event
4515 will tell us what kind of event it is. */
4516 g_signal_connect (G_OBJECT (weventbox
),
4517 "enter-notify-event",
4518 G_CALLBACK (xg_tool_bar_help_callback
),
4520 g_signal_connect (G_OBJECT (weventbox
),
4521 "leave-notify-event",
4522 G_CALLBACK (xg_tool_bar_help_callback
),
4526 if (wbutton
) *wbutton
= wb
;
4532 is_box_type (GtkWidget
*vb
, bool is_horizontal
)
4536 if (GTK_IS_BOX (vb
))
4538 GtkOrientation ori
= gtk_orientable_get_orientation (GTK_ORIENTABLE (vb
));
4539 ret
= (ori
== GTK_ORIENTATION_HORIZONTAL
&& is_horizontal
)
4540 || (ori
== GTK_ORIENTATION_VERTICAL
&& ! is_horizontal
);
4544 return is_horizontal
? GTK_IS_VBOX (vb
) : GTK_IS_HBOX (vb
);
4550 xg_tool_item_stale_p (GtkWidget
*wbutton
, const char *stock_name
,
4551 const char *icon_name
, const struct image
*img
,
4552 const char *label
, bool horiz
)
4556 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4557 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
4559 /* Check if the tool icon matches. */
4560 if (stock_name
&& wimage
)
4562 old
= g_object_get_data (G_OBJECT (wimage
),
4563 XG_TOOL_BAR_STOCK_NAME
);
4564 if (!old
|| strcmp (old
, stock_name
))
4567 else if (icon_name
&& wimage
)
4569 old
= g_object_get_data (G_OBJECT (wimage
),
4570 XG_TOOL_BAR_ICON_NAME
);
4571 if (!old
|| strcmp (old
, icon_name
))
4576 gpointer gold_img
= g_object_get_data (G_OBJECT (wimage
),
4577 XG_TOOL_BAR_IMAGE_DATA
);
4578 Pixmap old_img
= (Pixmap
) gold_img
;
4579 if (old_img
!= img
->pixmap
)
4583 /* Check button configuration and label. */
4584 if (is_box_type (vb
, horiz
)
4585 || (label
? (wlbl
== NULL
) : (wlbl
!= NULL
)))
4588 /* Ensure label is correct. */
4590 gtk_label_set_text (GTK_LABEL (wlbl
), label
);
4595 xg_update_tool_bar_sizes (struct frame
*f
)
4597 struct x_output
*x
= f
->output_data
.x
;
4599 int nl
= 0, nr
= 0, nt
= 0, nb
= 0;
4600 GtkWidget
*top_widget
= TOOLBAR_TOP_WIDGET (x
);
4602 gtk_widget_get_preferred_size (GTK_WIDGET (top_widget
), NULL
, &req
);
4603 if (x
->toolbar_in_hbox
)
4606 gtk_container_child_get (GTK_CONTAINER (x
->hbox_widget
),
4608 "position", &pos
, NULL
);
4609 if (pos
== 0) nl
= req
.width
;
4610 else nr
= req
.width
;
4615 gtk_container_child_get (GTK_CONTAINER (x
->vbox_widget
),
4617 "position", &pos
, NULL
);
4618 if (pos
== 0 || (pos
== 1 && x
->menubar_widget
)) nt
= req
.height
;
4619 else nb
= req
.height
;
4622 if (nl
!= FRAME_TOOLBAR_LEFT_WIDTH (f
)
4623 || nr
!= FRAME_TOOLBAR_RIGHT_WIDTH (f
)
4624 || nt
!= FRAME_TOOLBAR_TOP_HEIGHT (f
)
4625 || nb
!= FRAME_TOOLBAR_BOTTOM_HEIGHT (f
))
4627 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = FRAME_TOOLBAR_LEFT_WIDTH (f
)
4628 = FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4629 FRAME_TOOLBAR_LEFT_WIDTH (f
) = nl
;
4630 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = nr
;
4631 FRAME_TOOLBAR_TOP_HEIGHT (f
) = nt
;
4632 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = nb
;
4640 /* Update the tool bar for frame F. Add new buttons and remove old. */
4643 update_frame_tool_bar (struct frame
*f
)
4646 struct x_output
*x
= f
->output_data
.x
;
4647 int hmargin
= 0, vmargin
= 0;
4648 GtkToolbar
*wtoolbar
;
4650 GtkTextDirection dir
;
4652 bool text_image
, horiz
;
4653 struct xg_frame_tb_info
*tbinfo
;
4655 if (! FRAME_GTK_WIDGET (f
))
4660 if (RANGED_INTEGERP (1, Vtool_bar_button_margin
, INT_MAX
))
4662 hmargin
= XFASTINT (Vtool_bar_button_margin
);
4663 vmargin
= XFASTINT (Vtool_bar_button_margin
);
4665 else if (CONSP (Vtool_bar_button_margin
))
4667 if (RANGED_INTEGERP (1, XCAR (Vtool_bar_button_margin
), INT_MAX
))
4668 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
4670 if (RANGED_INTEGERP (1, XCDR (Vtool_bar_button_margin
), INT_MAX
))
4671 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
4674 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
4675 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
4676 i.e. zero. This means that margins less than
4677 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
4678 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4679 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4681 if (! x
->toolbar_widget
)
4682 xg_create_tool_bar (f
);
4684 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
4685 dir
= gtk_widget_get_direction (GTK_WIDGET (wtoolbar
));
4687 style
= Ftool_bar_get_system_style ();
4689 /* Are we up to date? */
4690 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4693 if (! NILP (tbinfo
->last_tool_bar
) && ! NILP (f
->tool_bar_items
)
4694 && tbinfo
->n_last_items
== f
->n_tool_bar_items
4695 && tbinfo
->hmargin
== hmargin
&& tbinfo
->vmargin
== vmargin
4696 && tbinfo
->dir
== dir
4697 && ! NILP (Fequal (tbinfo
->style
, style
))
4698 && ! NILP (Fequal (tbinfo
->last_tool_bar
, f
->tool_bar_items
)))
4704 tbinfo
->last_tool_bar
= f
->tool_bar_items
;
4705 tbinfo
->n_last_items
= f
->n_tool_bar_items
;
4706 tbinfo
->style
= style
;
4707 tbinfo
->hmargin
= hmargin
;
4708 tbinfo
->vmargin
= vmargin
;
4711 text_image
= EQ (style
, Qtext_image_horiz
);
4712 horiz
= EQ (style
, Qboth_horiz
) || text_image
;
4714 for (i
= j
= 0; i
< f
->n_tool_bar_items
; ++i
)
4716 bool enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
4717 bool selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
4721 struct image
*img
= NULL
;
4723 Lisp_Object stock
= Qnil
;
4724 GtkStockItem stock_item
;
4725 char *stock_name
= NULL
;
4726 char *icon_name
= NULL
;
4728 GtkWidget
*wbutton
= NULL
;
4729 Lisp_Object specified_file
;
4730 bool vert_only
= ! NILP (PROP (TOOL_BAR_ITEM_VERT_ONLY
));
4732 = (EQ (style
, Qimage
) || (vert_only
&& horiz
)) ? NULL
4733 : STRINGP (PROP (TOOL_BAR_ITEM_LABEL
))
4734 ? SSDATA (PROP (TOOL_BAR_ITEM_LABEL
))
4737 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4739 /* If this is a separator, use a gtk separator item. */
4740 if (EQ (PROP (TOOL_BAR_ITEM_TYPE
), Qt
))
4742 if (ti
== NULL
|| !GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4745 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4747 ti
= gtk_separator_tool_item_new ();
4748 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4754 /* Otherwise, the tool-bar item is an ordinary button. */
4756 if (ti
&& GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4758 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4762 if (ti
) wbutton
= XG_BIN_CHILD (XG_BIN_CHILD (ti
));
4764 /* Ignore invalid image specifications. */
4765 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4766 if (!valid_image_p (image
))
4769 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4774 specified_file
= file_for_image (image
);
4775 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
4776 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
4778 if (STRINGP (stock
))
4780 stock_name
= SSDATA (stock
);
4781 if (stock_name
[0] == 'n' && stock_name
[1] == ':')
4783 GdkScreen
*screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
4784 GtkIconTheme
*icon_theme
= gtk_icon_theme_get_for_screen (screen
);
4786 icon_name
= stock_name
+ 2;
4790 if (! gtk_icon_theme_has_icon (icon_theme
, icon_name
))
4793 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4795 else if (gtk_stock_lookup (SSDATA (stock
), &stock_item
))
4796 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4804 if (stock_name
== NULL
&& icon_name
== NULL
)
4806 /* No stock image, or stock item not known. Try regular
4807 image. If image is a vector, choose it according to the
4809 if (dir
== GTK_TEXT_DIR_RTL
4810 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
4812 image
= find_rtl_image (f
, image
, rtl
);
4814 if (VECTORP (image
))
4818 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
4819 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
4822 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
4823 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
4825 eassert (ASIZE (image
) >= idx
);
4826 image
= AREF (image
, idx
);
4831 img_id
= lookup_image (f
, image
);
4832 img
= IMAGE_FROM_ID (f
, img_id
);
4833 prepare_image_for_display (f
, img
);
4835 if (img
->load_failed_p
|| img
->pixmap
== None
)
4838 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4844 /* If there is an existing widget, check if it's stale; if so,
4845 remove it and make a new tool item from scratch. */
4846 if (ti
&& xg_tool_item_stale_p (wbutton
, stock_name
, icon_name
,
4849 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4858 /* Save the image so we can see if an update is needed the
4859 next time we call xg_tool_item_match_p. */
4860 if (EQ (style
, Qtext
))
4862 else if (stock_name
)
4864 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
4865 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
4866 (gpointer
) xstrdup (stock_name
),
4867 (GDestroyNotify
) xfree
);
4871 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
4872 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
4873 (gpointer
) xstrdup (icon_name
),
4874 (GDestroyNotify
) xfree
);
4878 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
4879 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
4880 (gpointer
)img
->pixmap
);
4883 if (w
) gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
4884 ti
= xg_make_tool_item (f
, w
, &wbutton
, label
, i
, horiz
, text_image
);
4885 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4890 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4894 /* Remove buttons not longer needed. */
4897 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4899 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4900 } while (ti
!= NULL
);
4902 if (f
->n_tool_bar_items
!= 0)
4904 if (! x
->toolbar_is_packed
)
4905 xg_pack_tool_bar (f
, f
->tool_bar_position
);
4906 gtk_widget_show_all (TOOLBAR_TOP_WIDGET (x
));
4907 if (xg_update_tool_bar_sizes (f
))
4908 xg_height_or_width_changed (f
);
4914 /* Deallocate all resources for the tool bar on frame F.
4915 Remove the tool bar. */
4918 free_frame_tool_bar (struct frame
*f
)
4920 struct x_output
*x
= f
->output_data
.x
;
4922 if (x
->toolbar_widget
)
4924 struct xg_frame_tb_info
*tbinfo
;
4925 GtkWidget
*top_widget
= TOOLBAR_TOP_WIDGET (x
);
4928 /* We may have created the toolbar_widget in xg_create_tool_bar, but
4929 not the x->handlebox_widget which is created in xg_pack_tool_bar. */
4930 if (x
->toolbar_is_packed
)
4932 if (x
->toolbar_in_hbox
)
4933 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4936 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4940 gtk_widget_destroy (x
->toolbar_widget
);
4942 x
->toolbar_widget
= 0;
4943 TOOLBAR_TOP_WIDGET (x
) = 0;
4944 x
->toolbar_is_packed
= false;
4945 FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4946 FRAME_TOOLBAR_LEFT_WIDTH (f
) = FRAME_TOOLBAR_RIGHT_WIDTH (f
) = 0;
4948 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4953 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4958 xg_height_or_width_changed (f
);
4965 xg_change_toolbar_position (struct frame
*f
, Lisp_Object pos
)
4967 struct x_output
*x
= f
->output_data
.x
;
4968 GtkWidget
*top_widget
= TOOLBAR_TOP_WIDGET (x
);
4970 if (! x
->toolbar_widget
|| ! top_widget
)
4974 g_object_ref (top_widget
);
4975 if (x
->toolbar_is_packed
)
4977 if (x
->toolbar_in_hbox
)
4978 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4981 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4985 xg_pack_tool_bar (f
, pos
);
4986 g_object_unref (top_widget
);
4987 if (xg_update_tool_bar_sizes (f
))
4988 xg_height_or_width_changed (f
);
4995 /***********************************************************************
4997 ***********************************************************************/
4999 xg_initialize (void)
5001 GtkBindingSet
*binding_set
;
5002 GtkSettings
*settings
;
5005 /* Work around a bug with corrupted data if libXft gets unloaded. This way
5006 we keep it permanently linked in. */
5011 xg_ignore_gtk_scrollbar
= 0;
5012 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
5013 xg_detached_menus
= 0;
5015 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
5016 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
5018 id_to_widget
.max_size
= id_to_widget
.used
= 0;
5019 id_to_widget
.widgets
= 0;
5021 settings
= gtk_settings_get_for_screen (gdk_display_get_default_screen
5022 (gdk_display_get_default ()));
5023 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
5024 bindings. It doesn't seem to be any way to remove properties,
5025 so we set it to "" which in means "no key". */
5026 gtk_settings_set_string_property (settings
,
5027 "gtk-menu-bar-accel",
5031 /* Make GTK text input widgets use Emacs style keybindings. This is
5033 gtk_settings_set_string_property (settings
,
5034 "gtk-key-theme-name",
5038 /* Make dialogs close on C-g. Since file dialog inherits from
5039 dialog, this works for them also. */
5040 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
5041 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
5044 /* Make menus close on C-g. */
5045 binding_set
= gtk_binding_set_by_class (g_type_class_ref
5046 (GTK_TYPE_MENU_SHELL
));
5047 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
5049 update_theme_scrollbar_width ();
5051 #ifdef HAVE_FREETYPE
5052 x_last_font_name
= NULL
;
5056 #endif /* USE_GTK */