1 /* Functions for creating and updating GTK widgets.
3 Copyright (C) 2003-2012 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/>. */
32 #include "blockinput.h"
33 #include "syssignal.h"
36 #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_MAJOR_VERSION > 2 || GTK_MINOR_VERSION > 11
76 #define remove_submenu(w) gtk_menu_item_set_submenu ((w), NULL)
78 #define remove_submenu(w) gtk_menu_item_remove_submenu ((w))
81 #if GTK_MAJOR_VERSION > 3 || (GTK_MAJOR_VERSION == 3 && GTK_MINOR_VERSION >= 2)
82 #define USE_NEW_GTK_FONT_CHOOSER 1
84 #define USE_NEW_GTK_FONT_CHOOSER 0
85 #define gtk_font_chooser_dialog_new(x, y) \
86 gtk_font_selection_dialog_new (x)
87 #undef GTK_FONT_CHOOSER
88 #define GTK_FONT_CHOOSER(x) GTK_FONT_SELECTION_DIALOG (x)
89 #define gtk_font_chooser_set_font(x, y) \
90 gtk_font_selection_dialog_set_font_name (x, y)
94 #ifdef USE_GTK_TOOLTIP
95 #define gdk_window_get_screen(w) gdk_drawable_get_screen (w)
97 #define gdk_window_get_geometry(w, a, b, c, d) \
98 gdk_window_get_geometry (w, a, b, c, d, 0)
99 #define gdk_x11_window_lookup_for_display(d, w) \
100 gdk_xid_table_lookup_for_display (d, w)
101 #define gtk_box_new(ori, spacing) \
102 ((ori) == GTK_ORIENTATION_HORIZONTAL \
103 ? gtk_hbox_new (FALSE, (spacing)) : gtk_vbox_new (FALSE, (spacing)))
104 #define gtk_scrollbar_new(ori, spacing) \
105 ((ori) == GTK_ORIENTATION_HORIZONTAL \
106 ? gtk_hscrollbar_new ((spacing)) : gtk_vscrollbar_new ((spacing)))
108 #define GDK_KEY_g GDK_g
110 #endif /* HAVE_GTK3 */
112 #define XG_BIN_CHILD(x) gtk_bin_get_child (GTK_BIN (x))
114 static void update_theme_scrollbar_width (void);
116 #define TB_INFO_KEY "xg_frame_tb_info"
117 struct xg_frame_tb_info
119 Lisp_Object last_tool_bar
;
122 int hmargin
, vmargin
;
123 GtkTextDirection dir
;
127 /***********************************************************************
128 Display handling functions
129 ***********************************************************************/
131 /* Keep track of the default display, or NULL if there is none. Emacs
132 may close all its displays. */
134 static GdkDisplay
*gdpy_def
;
136 /* When the GTK widget W is to be created on a display for F that
137 is not the default display, set the display for W.
138 W can be a GtkMenu or a GtkWindow widget. */
141 xg_set_screen (GtkWidget
*w
, FRAME_PTR f
)
143 if (FRAME_X_DISPLAY (f
) != DEFAULT_GDK_DISPLAY ())
145 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
146 GdkScreen
*gscreen
= gdk_display_get_default_screen (gdpy
);
149 gtk_menu_set_screen (GTK_MENU (w
), gscreen
);
151 gtk_window_set_screen (GTK_WINDOW (w
), gscreen
);
156 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
157 *DPY is set to NULL if the display can't be opened.
159 Returns non-zero if display could be opened, zero if display could not
160 be opened, and less than zero if the GTK version doesn't support
161 multiple displays. */
164 xg_display_open (char *display_name
, Display
**dpy
)
168 gdpy
= gdk_display_open (display_name
);
169 if (!gdpy_def
&& gdpy
)
172 gdk_display_manager_set_default_display (gdk_display_manager_get (),
176 *dpy
= gdpy
? GDK_DISPLAY_XDISPLAY (gdpy
) : NULL
;
180 /* Close display DPY. */
183 xg_display_close (Display
*dpy
)
185 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
187 /* If this is the default display, try to change it before closing.
188 If there is no other display to use, gdpy_def is set to NULL, and
189 the next call to xg_display_open resets the default display. */
190 if (gdk_display_get_default () == gdpy
)
192 struct x_display_info
*dpyinfo
;
193 GdkDisplay
*gdpy_new
= NULL
;
195 /* Find another display. */
196 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
197 if (dpyinfo
->display
!= dpy
)
199 gdpy_new
= gdk_x11_lookup_xdisplay (dpyinfo
->display
);
200 gdk_display_manager_set_default_display (gdk_display_manager_get (),
207 #if GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION < 10
208 /* GTK 2.2-2.8 has a bug that makes gdk_display_close crash (bug
209 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way we
210 can continue running, but there will be memory leaks. */
211 g_object_run_dispose (G_OBJECT (gdpy
));
213 /* This seems to be fixed in GTK 2.10. */
214 gdk_display_close (gdpy
);
219 /***********************************************************************
221 ***********************************************************************/
222 /* The next two variables and functions are taken from lwlib. */
223 static widget_value
*widget_value_free_list
;
224 static int malloc_cpt
;
226 /* Allocate a widget_value structure, either by taking one from the
227 widget_value_free_list or by malloc:ing a new one.
229 Return a pointer to the allocated structure. */
232 malloc_widget_value (void)
235 if (widget_value_free_list
)
237 wv
= widget_value_free_list
;
238 widget_value_free_list
= wv
->free_list
;
243 wv
= xmalloc (sizeof *wv
);
246 memset (wv
, 0, sizeof (widget_value
));
250 /* This is analogous to free. It frees only what was allocated
251 by malloc_widget_value, and no substructures. */
254 free_widget_value (widget_value
*wv
)
261 /* When the number of already allocated cells is too big,
268 wv
->free_list
= widget_value_free_list
;
269 widget_value_free_list
= wv
;
274 /* Create and return the cursor to be used for popup menus and
275 scroll bars on display DPY. */
278 xg_create_default_cursor (Display
*dpy
)
280 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
281 return gdk_cursor_new_for_display (gdpy
, GDK_LEFT_PTR
);
285 xg_get_pixbuf_from_pixmap (FRAME_PTR f
, Pixmap pix
)
290 unsigned int width
, height
, uunused
;
293 XGetGeometry (FRAME_X_DISPLAY (f
), pix
, &wunused
, &iunused
, &iunused
,
294 &width
, &height
, &uunused
, &uunused
);
296 xim
= XGetImage (FRAME_X_DISPLAY (f
), pix
, 0, 0, width
, height
,
300 tmp_buf
= gdk_pixbuf_new_from_data ((guchar
*) xim
->data
,
313 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
316 xg_get_pixbuf_from_pix_and_mask (FRAME_PTR f
,
321 GdkPixbuf
*icon_buf
, *tmp_buf
;
323 tmp_buf
= xg_get_pixbuf_from_pixmap (f
, pix
);
324 icon_buf
= gdk_pixbuf_add_alpha (tmp_buf
, FALSE
, 0, 0, 0);
325 g_object_unref (G_OBJECT (tmp_buf
));
327 width
= gdk_pixbuf_get_width (icon_buf
);
328 height
= gdk_pixbuf_get_height (icon_buf
);
332 GdkPixbuf
*mask_buf
= xg_get_pixbuf_from_pixmap (f
, mask
);
333 guchar
*pixels
= gdk_pixbuf_get_pixels (icon_buf
);
334 guchar
*mask_pixels
= gdk_pixbuf_get_pixels (mask_buf
);
335 int rowstride
= gdk_pixbuf_get_rowstride (icon_buf
);
336 int mask_rowstride
= gdk_pixbuf_get_rowstride (mask_buf
);
339 for (y
= 0; y
< height
; ++y
)
341 guchar
*iconptr
, *maskptr
;
344 iconptr
= pixels
+ y
* rowstride
;
345 maskptr
= mask_pixels
+ y
* mask_rowstride
;
347 for (x
= 0; x
< width
; ++x
)
349 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
350 just R is sufficient. */
352 iconptr
[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
354 iconptr
+= rowstride
/width
;
355 maskptr
+= mask_rowstride
/width
;
359 g_object_unref (G_OBJECT (mask_buf
));
366 file_for_image (Lisp_Object image
)
368 Lisp_Object specified_file
= Qnil
;
371 for (tail
= XCDR (image
);
372 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
373 tail
= XCDR (XCDR (tail
)))
374 if (EQ (XCAR (tail
), QCfile
))
375 specified_file
= XCAR (XCDR (tail
));
377 return specified_file
;
380 /* For the image defined in IMG, make and return a GtkImage. For displays with
381 8 planes or less we must make a GdkPixbuf and apply the mask manually.
382 Otherwise the highlighting and dimming the tool bar code in GTK does
383 will look bad. For display with more than 8 planes we just use the
384 pixmap and mask directly. For monochrome displays, GTK doesn't seem
385 able to use external pixmaps, it looks bad whatever we do.
386 The image is defined on the display where frame F is.
387 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
388 If OLD_WIDGET is NULL, a new widget is constructed and returned.
389 If OLD_WIDGET is not NULL, that widget is modified. */
392 xg_get_image_for_pixmap (FRAME_PTR f
,
395 GtkImage
*old_widget
)
399 /* If we have a file, let GTK do all the image handling.
400 This seems to be the only way to make insensitive and activated icons
401 look good in all cases. */
402 Lisp_Object specified_file
= file_for_image (img
->spec
);
405 /* We already loaded the image once before calling this
406 function, so this only fails if the image file has been removed.
407 In that case, use the pixmap already loaded. */
409 if (STRINGP (specified_file
)
410 && STRINGP (file
= x_find_image_file (specified_file
)))
413 old_widget
= GTK_IMAGE (gtk_image_new_from_file (SSDATA (file
)));
415 gtk_image_set_from_file (old_widget
, SSDATA (file
));
417 return GTK_WIDGET (old_widget
);
420 /* No file, do the image handling ourselves. This will look very bad
421 on a monochrome display, and sometimes bad on all displays with
424 /* This is a workaround to make icons look good on pseudo color
425 displays. Apparently GTK expects the images to have an alpha
426 channel. If they don't, insensitive and activated icons will
427 look bad. This workaround does not work on monochrome displays,
428 and is strictly not needed on true color/static color displays (i.e.
429 16 bits and higher). But we do it anyway so we get a pixbuf that is
430 not associated with the img->pixmap. The img->pixmap may be removed
431 by clearing the image cache and then the tool bar redraw fails, since
432 Gtk+ assumes the pixmap is always there. */
433 icon_buf
= xg_get_pixbuf_from_pix_and_mask (f
, img
->pixmap
, img
->mask
);
438 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
440 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
442 g_object_unref (G_OBJECT (icon_buf
));
445 return GTK_WIDGET (old_widget
);
449 /* Set CURSOR on W and all widgets W contain. We must do like this
450 for scroll bars and menu because they create widgets internally,
451 and it is those widgets that are visible. */
454 xg_set_cursor (GtkWidget
*w
, GdkCursor
*cursor
)
456 GdkWindow
*window
= gtk_widget_get_window (w
);
457 GList
*children
= gdk_window_peek_children (window
);
459 gdk_window_set_cursor (window
, cursor
);
461 /* The scroll bar widget has more than one GDK window (had to look at
462 the source to figure this out), and there is no way to set cursor
463 on widgets in GTK. So we must set the cursor for all GDK windows.
466 for ( ; children
; children
= g_list_next (children
))
467 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
470 /* Insert NODE into linked LIST. */
473 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
475 xg_list_node
*list_start
= list
->next
;
477 if (list_start
) list_start
->prev
= node
;
478 node
->next
= list_start
;
483 /* Remove NODE from linked LIST. */
486 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
488 xg_list_node
*list_start
= list
->next
;
489 if (node
== list_start
)
491 list
->next
= node
->next
;
492 if (list
->next
) list
->next
->prev
= 0;
496 node
->prev
->next
= node
->next
;
497 if (node
->next
) node
->next
->prev
= node
->prev
;
501 /* Allocate and return a utf8 version of STR. If STR is already
502 utf8 or NULL, just return a copy of STR.
503 A new string is allocated and the caller must free the result
507 get_utf8_string (const char *str
)
511 if (!str
) return NULL
;
513 /* If not UTF-8, try current locale. */
514 if (!g_utf8_validate (str
, -1, NULL
))
515 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
517 return g_strdup (str
);
521 /* Probably some control characters in str. Escape them. */
523 ptrdiff_t nr_bad
= 0;
526 unsigned char *p
= (unsigned char *)str
;
530 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
531 &bytes_written
, &err
))
532 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
535 p
+= bytes_written
+1;
548 if ((min (PTRDIFF_MAX
, SIZE_MAX
) - len
- 1) / 4 < nr_bad
)
549 memory_full (SIZE_MAX
);
550 up
= utf8_str
= xmalloc (len
+ nr_bad
* 4 + 1);
551 p
= (unsigned char *)str
;
553 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
554 &bytes_written
, &err
))
555 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
557 memcpy (up
, p
, bytes_written
);
558 sprintf (up
+ bytes_written
, "\\%03o", p
[bytes_written
]);
559 up
+= bytes_written
+4;
560 p
+= bytes_written
+1;
567 strcat (utf8_str
, cp
);
579 /* Check for special colors used in face spec for region face.
580 The colors are fetched from the Gtk+ theme.
581 Return 1 if color was found, 0 if not. */
584 xg_check_special_colors (struct frame
*f
,
585 const char *color_name
,
589 int get_bg
= strcmp ("gtk_selection_bg_color", color_name
) == 0;
590 int get_fg
= !get_bg
&& strcmp ("gtk_selection_fg_color", color_name
) == 0;
592 if (! FRAME_GTK_WIDGET (f
) || ! (get_bg
|| get_fg
))
598 GtkStyleContext
*gsty
599 = gtk_widget_get_style_context (FRAME_GTK_OUTER_WIDGET (f
));
601 char buf
[sizeof "rgbi://" + 3 * (DBL_MAX_10_EXP
+ sizeof "-1.000000" - 1)];
602 int state
= GTK_STATE_FLAG_SELECTED
|GTK_STATE_FLAG_FOCUSED
;
604 gtk_style_context_get_color (gsty
, state
, &col
);
606 gtk_style_context_get_background_color (gsty
, state
, &col
);
608 sprintf (buf
, "rgbi:%lf/%lf/%lf", col
.red
, col
.green
, col
.blue
);
609 success_p
= XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
612 GtkStyle
*gsty
= gtk_widget_get_style (FRAME_GTK_WIDGET (f
));
613 GdkColor
*grgb
= get_bg
614 ? &gsty
->bg
[GTK_STATE_SELECTED
]
615 : &gsty
->fg
[GTK_STATE_SELECTED
];
617 color
->red
= grgb
->red
;
618 color
->green
= grgb
->green
;
619 color
->blue
= grgb
->blue
;
620 color
->pixel
= grgb
->pixel
;
631 /***********************************************************************
633 ***********************************************************************/
634 /* Gtk+ calls this callback when the parent of our tooltip dummy changes.
635 We use that to pop down the tooltip. This happens if Gtk+ for some
636 reason wants to change or hide the tooltip. */
638 #ifdef USE_GTK_TOOLTIP
641 hierarchy_ch_cb (GtkWidget
*widget
,
642 GtkWidget
*previous_toplevel
,
645 FRAME_PTR f
= (FRAME_PTR
) user_data
;
646 struct x_output
*x
= f
->output_data
.x
;
647 GtkWidget
*top
= gtk_widget_get_toplevel (x
->ttip_lbl
);
649 if (! top
|| ! GTK_IS_WINDOW (top
))
650 gtk_widget_hide (previous_toplevel
);
653 /* Callback called when Gtk+ thinks a tooltip should be displayed.
654 We use it to get the tooltip window and the tooltip widget so
655 we can manipulate the ourselves.
657 Return FALSE ensures that the tooltip is not shown. */
660 qttip_cb (GtkWidget
*widget
,
663 gboolean keyboard_mode
,
667 FRAME_PTR f
= (FRAME_PTR
) user_data
;
668 struct x_output
*x
= f
->output_data
.x
;
669 if (x
->ttip_widget
== NULL
)
674 g_object_set (G_OBJECT (widget
), "has-tooltip", FALSE
, NULL
);
675 x
->ttip_widget
= tooltip
;
676 g_object_ref (G_OBJECT (tooltip
));
677 x
->ttip_lbl
= gtk_label_new ("");
678 g_object_ref (G_OBJECT (x
->ttip_lbl
));
679 gtk_tooltip_set_custom (tooltip
, x
->ttip_lbl
);
680 x
->ttip_window
= GTK_WINDOW (gtk_widget_get_toplevel (x
->ttip_lbl
));
682 /* Change stupid Gtk+ default line wrapping. */
683 p
= gtk_widget_get_parent (x
->ttip_lbl
);
684 list
= gtk_container_get_children (GTK_CONTAINER (p
));
685 for (iter
= list
; iter
; iter
= g_list_next (iter
))
687 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
688 if (GTK_IS_LABEL (w
))
689 gtk_label_set_line_wrap (GTK_LABEL (w
), FALSE
);
693 /* ATK needs an empty title for some reason. */
694 gtk_window_set_title (x
->ttip_window
, "");
695 /* Realize so we can safely get screen later on. */
696 gtk_widget_realize (GTK_WIDGET (x
->ttip_window
));
697 gtk_widget_realize (x
->ttip_lbl
);
699 g_signal_connect (x
->ttip_lbl
, "hierarchy-changed",
700 G_CALLBACK (hierarchy_ch_cb
), f
);
705 #endif /* USE_GTK_TOOLTIP */
707 /* Prepare a tooltip to be shown, i.e. calculate WIDTH and HEIGHT.
708 Return zero if no system tooltip available, non-zero otherwise. */
711 xg_prepare_tooltip (FRAME_PTR f
,
716 #ifndef USE_GTK_TOOLTIP
719 struct x_output
*x
= f
->output_data
.x
;
723 GtkSettings
*settings
;
724 gboolean tt_enabled
= TRUE
;
726 Lisp_Object encoded_string
;
728 if (!x
->ttip_lbl
) return 0;
731 encoded_string
= ENCODE_UTF_8 (string
);
732 widget
= GTK_WIDGET (x
->ttip_lbl
);
733 gwin
= gtk_widget_get_window (GTK_WIDGET (x
->ttip_window
));
734 screen
= gdk_window_get_screen (gwin
);
735 settings
= gtk_settings_get_for_screen (screen
);
736 g_object_get (settings
, "gtk-enable-tooltips", &tt_enabled
, NULL
);
739 g_object_set (settings
, "gtk-enable-tooltips", FALSE
, NULL
);
740 /* Record that we disabled it so it can be enabled again. */
741 g_object_set_data (G_OBJECT (x
->ttip_window
), "restore-tt",
745 /* Prevent Gtk+ from hiding tooltip on mouse move and such. */
746 g_object_set_data (G_OBJECT
747 (gtk_widget_get_display (GTK_WIDGET (x
->ttip_window
))),
748 "gdk-display-current-tooltip", NULL
);
750 /* Put our dummy widget in so we can get callbacks for unrealize and
751 hierarchy-changed. */
752 gtk_tooltip_set_custom (x
->ttip_widget
, widget
);
753 gtk_tooltip_set_text (x
->ttip_widget
, SSDATA (encoded_string
));
754 gtk_widget_get_preferred_size (GTK_WIDGET (x
->ttip_window
), NULL
, &req
);
755 if (width
) *width
= req
.width
;
756 if (height
) *height
= req
.height
;
761 #endif /* USE_GTK_TOOLTIP */
764 /* Show the tooltip at ROOT_X and ROOT_Y.
765 xg_prepare_tooltip must have been called before this function. */
768 xg_show_tooltip (FRAME_PTR f
, int root_x
, int root_y
)
770 #ifdef USE_GTK_TOOLTIP
771 struct x_output
*x
= f
->output_data
.x
;
775 gtk_window_move (x
->ttip_window
, root_x
, root_y
);
776 gtk_widget_show_all (GTK_WIDGET (x
->ttip_window
));
782 /* Hide tooltip if shown. Do nothing if not shown.
783 Return non-zero if tip was hidden, non-zero if not (i.e. not using
787 xg_hide_tooltip (FRAME_PTR f
)
790 #ifdef USE_GTK_TOOLTIP
791 if (f
->output_data
.x
->ttip_window
)
793 GtkWindow
*win
= f
->output_data
.x
->ttip_window
;
795 gtk_widget_hide (GTK_WIDGET (win
));
797 if (g_object_get_data (G_OBJECT (win
), "restore-tt"))
799 GdkWindow
*gwin
= gtk_widget_get_window (GTK_WIDGET (win
));
800 GdkScreen
*screen
= gdk_window_get_screen (gwin
);
801 GtkSettings
*settings
= gtk_settings_get_for_screen (screen
);
802 g_object_set (settings
, "gtk-enable-tooltips", TRUE
, NULL
);
813 /***********************************************************************
814 General functions for creating widgets, resizing, events, e.t.c.
815 ***********************************************************************/
817 /* Make a geometry string and pass that to GTK. It seems this is the
818 only way to get geometry position right if the user explicitly
819 asked for a position when starting Emacs.
820 F is the frame we shall set geometry for. */
823 xg_set_geometry (FRAME_PTR f
)
825 if (f
->size_hint_flags
& (USPosition
| PPosition
))
827 int left
= f
->left_pos
;
828 int xneg
= f
->size_hint_flags
& XNegative
;
829 int top
= f
->top_pos
;
830 int yneg
= f
->size_hint_flags
& YNegative
;
831 char geom_str
[sizeof "=x--" + 4 * INT_STRLEN_BOUND (int)];
838 sprintf (geom_str
, "=%dx%d%c%d%c%d",
839 FRAME_PIXEL_WIDTH (f
),
840 FRAME_PIXEL_HEIGHT (f
),
841 (xneg
? '-' : '+'), left
,
842 (yneg
? '-' : '+'), top
);
844 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
846 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
850 /* Clear under internal border if any. As we use a mix of Gtk+ and X calls
851 and use a GtkFixed widget, this doesn't happen automatically. */
854 xg_clear_under_internal_border (FRAME_PTR f
)
856 if (FRAME_INTERNAL_BORDER_WIDTH (f
) > 0)
858 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
859 gtk_widget_queue_draw (wfixed
);
860 gdk_window_process_all_updates ();
861 x_clear_area (FRAME_X_DISPLAY (f
),
864 FRAME_PIXEL_WIDTH (f
),
865 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
866 x_clear_area (FRAME_X_DISPLAY (f
),
869 FRAME_INTERNAL_BORDER_WIDTH (f
),
870 FRAME_PIXEL_HEIGHT (f
), 0);
871 x_clear_area (FRAME_X_DISPLAY (f
),
873 0, FRAME_PIXEL_HEIGHT (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
874 FRAME_PIXEL_WIDTH (f
),
875 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
876 x_clear_area (FRAME_X_DISPLAY (f
),
878 FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
880 FRAME_INTERNAL_BORDER_WIDTH (f
),
881 FRAME_PIXEL_HEIGHT (f
), 0);
885 /* Function to handle resize of our frame. As we have a Gtk+ tool bar
886 and a Gtk+ menu bar, we get resize events for the edit part of the
887 frame only. We let Gtk+ deal with the Gtk+ parts.
888 F is the frame to resize.
889 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
892 xg_frame_resized (FRAME_PTR f
, int pixelwidth
, int pixelheight
)
896 if (pixelwidth
== -1 && pixelheight
== -1)
898 if (FRAME_GTK_WIDGET (f
) && gtk_widget_get_mapped (FRAME_GTK_WIDGET (f
)))
899 gdk_window_get_geometry (gtk_widget_get_window (FRAME_GTK_WIDGET (f
)),
901 &pixelwidth
, &pixelheight
);
906 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, pixelheight
);
907 columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pixelwidth
);
909 if (columns
!= FRAME_COLS (f
)
910 || rows
!= FRAME_LINES (f
)
911 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
912 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
))
914 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
915 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
917 xg_clear_under_internal_border (f
);
918 change_frame_size (f
, rows
, columns
, 0, 1, 0);
919 SET_FRAME_GARBAGED (f
);
920 cancel_mouse_face (f
);
924 /* Resize the outer window of frame F after changing the height.
925 COLUMNS/ROWS is the size the edit area shall have after the resize. */
928 xg_frame_set_char_size (FRAME_PTR f
, int cols
, int rows
)
930 int pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
)
931 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
934 if (FRAME_PIXEL_HEIGHT (f
) == 0)
937 /* Take into account the size of the scroll bar. Always use the
938 number of columns occupied by the scroll bar here otherwise we
939 might end up with a frame width that is not a multiple of the
940 frame's character width which is bad for vertically split
942 f
->scroll_bar_actual_width
943 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
945 compute_fringe_widths (f
, 0);
947 /* FRAME_TEXT_COLS_TO_PIXEL_WIDTH uses scroll_bar_actual_width, so call it
948 after calculating that value. */
949 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
)
950 + FRAME_TOOLBAR_WIDTH (f
);
953 /* Do this before resize, as we don't know yet if we will be resized. */
954 xg_clear_under_internal_border (f
);
956 /* Must resize our top level widget. Font size may have changed,
957 but not rows/cols. */
958 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
959 pixelwidth
, pixelheight
);
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 (f
->async_visible
)
974 /* Must call this to flush out events */
975 (void)gtk_events_pending ();
977 x_wait_for_event (f
, ConfigureNotify
);
981 change_frame_size (f
, rows
, cols
, 0, 1, 0);
982 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
983 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
987 /* Handle height/width changes (i.e. add/remove/move menu/toolbar).
988 The policy is to keep the number of editable lines. */
991 xg_height_or_width_changed (FRAME_PTR f
)
993 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
994 FRAME_TOTAL_PIXEL_WIDTH (f
),
995 FRAME_TOTAL_PIXEL_HEIGHT (f
));
996 f
->output_data
.x
->hint_flags
= 0;
997 x_wm_set_size_hint (f
, 0, 0);
1000 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
1001 Must be done like this, because GtkWidget:s can have "hidden"
1002 X Window that aren't accessible.
1004 Return 0 if no widget match WDESC. */
1007 xg_win_to_widget (Display
*dpy
, Window wdesc
)
1010 GtkWidget
*gwdesc
= 0;
1014 gdkwin
= gdk_x11_window_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
1019 event
.any
.window
= gdkwin
;
1020 event
.any
.type
= GDK_NOTHING
;
1021 gwdesc
= gtk_get_event_widget (&event
);
1028 /* Set the background of widget W to PIXEL. */
1031 xg_set_widget_bg (FRAME_PTR f
, GtkWidget
*w
, long unsigned int pixel
)
1037 if (XQueryColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &xbg
))
1039 bg
.red
= (double)xbg
.red
/65536.0;
1040 bg
.green
= (double)xbg
.green
/65536.0;
1041 bg
.blue
= (double)xbg
.blue
/65536.0;
1043 gtk_widget_override_background_color (w
, GTK_STATE_FLAG_NORMAL
, &bg
);
1047 GdkColormap
*map
= gtk_widget_get_colormap (w
);
1048 gdk_colormap_query_color (map
, pixel
, &bg
);
1049 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &bg
);
1053 /* Callback called when the gtk theme changes.
1054 We notify lisp code so it can fix faces used for region for example. */
1057 style_changed_cb (GObject
*go
,
1061 struct input_event event
;
1062 GdkDisplay
*gdpy
= (GdkDisplay
*) user_data
;
1063 const char *display_name
= gdk_display_get_name (gdpy
);
1064 Display
*dpy
= GDK_DISPLAY_XDISPLAY (gdpy
);
1067 event
.kind
= CONFIG_CHANGED_EVENT
;
1068 event
.frame_or_window
= build_string (display_name
);
1069 /* Theme doesn't change often, so intern is called seldom. */
1070 event
.arg
= intern ("theme-name");
1071 kbd_buffer_store_event (&event
);
1073 update_theme_scrollbar_width ();
1075 /* If scroll bar width changed, we need set the new size on all frames
1079 Lisp_Object rest
, frame
;
1080 FOR_EACH_FRAME (rest
, frame
)
1082 FRAME_PTR f
= XFRAME (frame
);
1083 if (FRAME_X_DISPLAY (f
) == dpy
)
1085 x_set_scroll_bar_default_width (f
);
1086 xg_frame_set_char_size (f
, FRAME_COLS (f
), FRAME_LINES (f
));
1092 /* Called when a delete-event occurs on WIDGET. */
1095 delete_cb (GtkWidget
*widget
,
1100 /* The event doesn't arrive in the normal event loop. Send event
1102 FRAME_PTR f
= (FRAME_PTR
) user_data
;
1103 struct input_event ie
;
1106 ie
.kind
= DELETE_WINDOW_EVENT
;
1107 XSETFRAME (ie
.frame_or_window
, f
);
1108 kbd_buffer_store_event (&ie
);
1114 /* Create and set up the GTK widgets for frame F.
1115 Return 0 if creation failed, non-zero otherwise. */
1118 xg_create_frame_widgets (FRAME_PTR f
)
1121 GtkWidget
*wvbox
, *whbox
;
1130 if (FRAME_X_EMBEDDED_P (f
))
1132 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
1133 wtop
= gtk_plug_new_for_display (gdpy
, f
->output_data
.x
->parent_desc
);
1136 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
1138 /* gtk_window_set_has_resize_grip is a Gtk+ 3.0 function but Ubuntu
1139 has backported it to Gtk+ 2.0 and they add the resize grip for
1140 Gtk+ 2.0 applications also. But it has a bug that makes Emacs loop
1141 forever, so disable the grip. */
1142 #if GTK_MAJOR_VERSION < 3 && defined (HAVE_GTK_WINDOW_SET_HAS_RESIZE_GRIP)
1143 gtk_window_set_has_resize_grip (GTK_WINDOW (wtop
), FALSE
);
1146 xg_set_screen (wtop
, f
);
1148 wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1149 whbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1150 gtk_box_set_homogeneous (GTK_BOX (wvbox
), FALSE
);
1151 gtk_box_set_homogeneous (GTK_BOX (whbox
), FALSE
);
1154 wfixed
= emacs_fixed_new (f
);
1156 wfixed
= gtk_fixed_new ();
1159 if (! wtop
|| ! wvbox
|| ! whbox
|| ! wfixed
)
1161 if (wtop
) gtk_widget_destroy (wtop
);
1162 if (wvbox
) gtk_widget_destroy (wvbox
);
1163 if (whbox
) gtk_widget_destroy (whbox
);
1164 if (wfixed
) gtk_widget_destroy (wfixed
);
1170 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
1171 gtk_widget_set_name (wtop
, EMACS_CLASS
);
1172 gtk_widget_set_name (wvbox
, "pane");
1173 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
1175 /* If this frame has a title or name, set it in the title bar. */
1176 if (! NILP (f
->title
))
1177 title
= SSDATA (ENCODE_UTF_8 (f
->title
));
1178 else if (! NILP (f
->name
))
1179 title
= SSDATA (ENCODE_UTF_8 (f
->name
));
1181 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
1183 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
1184 FRAME_GTK_WIDGET (f
) = wfixed
;
1185 f
->output_data
.x
->vbox_widget
= wvbox
;
1186 f
->output_data
.x
->hbox_widget
= whbox
;
1188 gtk_widget_set_has_window (wfixed
, TRUE
);
1190 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
1191 gtk_box_pack_start (GTK_BOX (wvbox
), whbox
, TRUE
, TRUE
, 0);
1192 gtk_box_pack_start (GTK_BOX (whbox
), wfixed
, TRUE
, TRUE
, 0);
1194 if (FRAME_EXTERNAL_TOOL_BAR (f
))
1195 update_frame_tool_bar (f
);
1197 /* We don't want this widget double buffered, because we draw on it
1198 with regular X drawing primitives, so from a GTK/GDK point of
1199 view, the widget is totally blank. When an expose comes, this
1200 will make the widget blank, and then Emacs redraws it. This flickers
1201 a lot, so we turn off double buffering. */
1202 gtk_widget_set_double_buffered (wfixed
, FALSE
);
1204 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
1205 SSDATA (Vx_resource_name
),
1206 SSDATA (Vx_resource_class
));
1208 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
1209 GTK is to destroy the widget. We want Emacs to do that instead. */
1210 g_signal_connect (G_OBJECT (wtop
), "delete-event",
1211 G_CALLBACK (delete_cb
), f
);
1213 /* Convert our geometry parameters into a geometry string
1215 GTK will itself handle calculating the real position this way. */
1216 xg_set_geometry (f
);
1218 = gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1220 gtk_widget_add_events (wfixed
,
1221 GDK_POINTER_MOTION_MASK
1223 | GDK_BUTTON_PRESS_MASK
1224 | GDK_BUTTON_RELEASE_MASK
1225 | GDK_KEY_PRESS_MASK
1226 | GDK_ENTER_NOTIFY_MASK
1227 | GDK_LEAVE_NOTIFY_MASK
1228 | GDK_FOCUS_CHANGE_MASK
1229 | GDK_STRUCTURE_MASK
1230 | GDK_VISIBILITY_NOTIFY_MASK
);
1232 /* Must realize the windows so the X window gets created. It is used
1233 by callers of this function. */
1234 gtk_widget_realize (wfixed
);
1235 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
1237 /* Since GTK clears its window by filling with the background color,
1238 we must keep X and GTK background in sync. */
1239 xg_set_widget_bg (f
, wfixed
, FRAME_BACKGROUND_PIXEL (f
));
1242 /* Also, do not let any background pixmap to be set, this looks very
1243 bad as Emacs overwrites the background pixmap with its own idea
1244 of background color. */
1245 style
= gtk_widget_get_modifier_style (wfixed
);
1247 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
1248 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
1249 gtk_widget_modify_style (wfixed
, style
);
1251 gtk_widget_set_can_focus (wfixed
, TRUE
);
1252 gtk_window_set_resizable (GTK_WINDOW (wtop
), TRUE
);
1255 #ifdef USE_GTK_TOOLTIP
1256 /* Steal a tool tip window we can move ourselves. */
1257 f
->output_data
.x
->ttip_widget
= 0;
1258 f
->output_data
.x
->ttip_lbl
= 0;
1259 f
->output_data
.x
->ttip_window
= 0;
1260 gtk_widget_set_tooltip_text (wtop
, "Dummy text");
1261 g_signal_connect (wtop
, "query-tooltip", G_CALLBACK (qttip_cb
), f
);
1265 GdkScreen
*screen
= gtk_widget_get_screen (wtop
);
1266 GtkSettings
*gs
= gtk_settings_get_for_screen (screen
);
1267 /* Only connect this signal once per screen. */
1268 if (! g_signal_handler_find (G_OBJECT (gs
),
1269 G_SIGNAL_MATCH_FUNC
,
1271 G_CALLBACK (style_changed_cb
),
1274 g_signal_connect (G_OBJECT (gs
), "notify::gtk-theme-name",
1275 G_CALLBACK (style_changed_cb
),
1276 gdk_screen_get_display (screen
));
1286 xg_free_frame_widgets (FRAME_PTR f
)
1288 if (FRAME_GTK_OUTER_WIDGET (f
))
1290 #ifdef USE_GTK_TOOLTIP
1291 struct x_output
*x
= f
->output_data
.x
;
1293 struct xg_frame_tb_info
*tbinfo
1294 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
1299 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f
));
1300 FRAME_X_WINDOW (f
) = 0; /* Set to avoid XDestroyWindow in xterm.c */
1301 FRAME_GTK_OUTER_WIDGET (f
) = 0;
1302 #ifdef USE_GTK_TOOLTIP
1304 gtk_widget_destroy (x
->ttip_lbl
);
1306 g_object_unref (G_OBJECT (x
->ttip_widget
));
1311 /* Set the normal size hints for the window manager, for frame F.
1312 FLAGS is the flags word to use--or 0 meaning preserve the flags
1313 that the window now has.
1314 If USER_POSITION is nonzero, we set the User Position
1315 flag (this is useful when FLAGS is 0). */
1318 x_wm_set_size_hint (FRAME_PTR f
, long int flags
, int user_position
)
1320 /* Must use GTK routines here, otherwise GTK resets the size hints
1321 to its own defaults. */
1322 GdkGeometry size_hints
;
1323 gint hint_flags
= 0;
1324 int base_width
, base_height
;
1325 int min_rows
= 0, min_cols
= 0;
1326 int win_gravity
= f
->win_gravity
;
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
))
1336 memset (&size_hints
, 0, sizeof (size_hints
));
1337 f
->output_data
.x
->size_hints
= size_hints
;
1338 f
->output_data
.x
->hint_flags
= hint_flags
;
1341 flags
= f
->size_hint_flags
;
1343 size_hints
= f
->output_data
.x
->size_hints
;
1344 hint_flags
= f
->output_data
.x
->hint_flags
;
1346 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
1347 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
1348 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
1350 hint_flags
|= GDK_HINT_BASE_SIZE
;
1351 /* Use one row/col here so base_height/width does not become zero.
1352 Gtk+ and/or Unity on Ubuntu 12.04 can't handle it. */
1353 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 1) + FRAME_TOOLBAR_WIDTH (f
);
1354 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 1)
1355 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
1357 check_frame_size (f
, &min_rows
, &min_cols
);
1358 if (min_cols
> 0) --min_cols
; /* We used one col in base_width = ... 1); */
1359 if (min_rows
> 0) --min_rows
; /* We used one row in base_height = ... 1); */
1361 size_hints
.base_width
= base_width
;
1362 size_hints
.base_height
= base_height
;
1363 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
1364 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
1366 /* These currently have a one to one mapping with the X values, but I
1367 don't think we should rely on that. */
1368 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
1369 size_hints
.win_gravity
= 0;
1370 if (win_gravity
== NorthWestGravity
)
1371 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
1372 else if (win_gravity
== NorthGravity
)
1373 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
1374 else if (win_gravity
== NorthEastGravity
)
1375 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
1376 else if (win_gravity
== WestGravity
)
1377 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
1378 else if (win_gravity
== CenterGravity
)
1379 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
1380 else if (win_gravity
== EastGravity
)
1381 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
1382 else if (win_gravity
== SouthWestGravity
)
1383 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
1384 else if (win_gravity
== SouthGravity
)
1385 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
1386 else if (win_gravity
== SouthEastGravity
)
1387 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
1388 else if (win_gravity
== StaticGravity
)
1389 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
1393 hint_flags
&= ~GDK_HINT_POS
;
1394 hint_flags
|= GDK_HINT_USER_POS
;
1397 if (hint_flags
!= f
->output_data
.x
->hint_flags
1398 || memcmp (&size_hints
,
1399 &f
->output_data
.x
->size_hints
,
1400 sizeof (size_hints
)) != 0)
1403 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1404 NULL
, &size_hints
, hint_flags
);
1405 f
->output_data
.x
->size_hints
= size_hints
;
1406 f
->output_data
.x
->hint_flags
= hint_flags
;
1411 /* Change background color of a frame.
1412 Since GTK uses the background color to clear the window, we must
1413 keep the GTK and X colors in sync.
1414 F is the frame to change,
1415 BG is the pixel value to change to. */
1418 xg_set_background_color (FRAME_PTR f
, long unsigned int bg
)
1420 if (FRAME_GTK_WIDGET (f
))
1423 xg_set_widget_bg (f
, FRAME_GTK_WIDGET (f
), FRAME_BACKGROUND_PIXEL (f
));
1429 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1430 functions so GTK does not overwrite the icon. */
1433 xg_set_frame_icon (FRAME_PTR f
, Pixmap icon_pixmap
, Pixmap icon_mask
)
1435 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (f
,
1439 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
1444 /***********************************************************************
1446 ***********************************************************************/
1447 /* Return the dialog title to use for a dialog of type KEY.
1448 This is the encoding used by lwlib. We use the same for GTK. */
1451 get_dialog_title (char key
)
1453 const char *title
= "";
1461 title
= "Information";
1480 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1481 the dialog, but return TRUE so the event does not propagate further
1482 in GTK. This prevents GTK from destroying the dialog widget automatically
1483 and we can always destroy the widget manually, regardless of how
1484 it was popped down (button press or WM_DELETE_WINDOW).
1485 W is the dialog widget.
1486 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1487 user_data is NULL (not used).
1489 Returns TRUE to end propagation of event. */
1492 dialog_delete_callback (GtkWidget
*w
, GdkEvent
*event
, gpointer user_data
)
1494 gtk_widget_unmap (w
);
1498 /* Create a popup dialog window. See also xg_create_widget below.
1499 WV is a widget_value describing the dialog.
1500 SELECT_CB is the callback to use when a button has been pressed.
1501 DEACTIVATE_CB is the callback to use when the dialog pops down.
1503 Returns the GTK dialog widget. */
1506 create_dialog (widget_value
*wv
,
1507 GCallback select_cb
,
1508 GCallback deactivate_cb
)
1510 const char *title
= get_dialog_title (wv
->name
[0]);
1511 int total_buttons
= wv
->name
[1] - '0';
1512 int right_buttons
= wv
->name
[4] - '0';
1515 int button_spacing
= 10;
1516 GtkWidget
*wdialog
= gtk_dialog_new ();
1517 GtkDialog
*wd
= GTK_DIALOG (wdialog
);
1518 GtkBox
*cur_box
= GTK_BOX (gtk_dialog_get_action_area (wd
));
1520 GtkWidget
*whbox_down
;
1522 /* If the number of buttons is greater than 4, make two rows of buttons
1523 instead. This looks better. */
1524 int make_two_rows
= total_buttons
> 4;
1526 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1527 left_buttons
= total_buttons
- right_buttons
;
1529 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1530 gtk_widget_set_name (wdialog
, "emacs-dialog");
1535 GtkWidget
*wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, button_spacing
);
1536 GtkWidget
*whbox_up
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1537 gtk_box_set_homogeneous (GTK_BOX (wvbox
), TRUE
);
1538 gtk_box_set_homogeneous (GTK_BOX (whbox_up
), FALSE
);
1539 whbox_down
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1540 gtk_box_set_homogeneous (GTK_BOX (whbox_down
), FALSE
);
1542 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1543 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1544 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1546 cur_box
= GTK_BOX (whbox_up
);
1549 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1550 G_CALLBACK (dialog_delete_callback
), 0);
1554 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1555 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1558 for (item
= wv
->contents
; item
; item
= item
->next
)
1560 char *utf8_label
= get_utf8_string (item
->value
);
1564 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1566 GtkBox
*wvbox
= GTK_BOX (gtk_dialog_get_content_area (wd
));
1567 /* This is the text part of the dialog. */
1568 w
= gtk_label_new (utf8_label
);
1569 gtk_box_pack_start (wvbox
, gtk_label_new (""), FALSE
, FALSE
, 0);
1570 gtk_box_pack_start (wvbox
, w
, TRUE
, TRUE
, 0);
1571 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1573 /* Try to make dialog look better. Must realize first so
1574 the widget can calculate the size it needs. */
1575 gtk_widget_realize (w
);
1576 gtk_widget_get_preferred_size (w
, NULL
, &req
);
1577 gtk_box_set_spacing (wvbox
, req
.height
);
1578 if (item
->value
&& strlen (item
->value
) > 0)
1579 button_spacing
= 2*req
.width
/strlen (item
->value
);
1583 /* This is one button to add to the dialog. */
1584 w
= gtk_button_new_with_label (utf8_label
);
1585 if (! item
->enabled
)
1586 gtk_widget_set_sensitive (w
, FALSE
);
1588 g_signal_connect (G_OBJECT (w
), "clicked",
1589 select_cb
, item
->call_data
);
1591 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1592 if (++button_nr
== left_buttons
)
1595 cur_box
= GTK_BOX (whbox_down
);
1597 gtk_box_pack_start (cur_box
,
1605 g_free (utf8_label
);
1611 struct xg_dialog_data
1619 /* Function that is called when the file or font dialogs pop down.
1620 W is the dialog widget, RESPONSE is the response code.
1621 USER_DATA is what we passed in to g_signal_connect. */
1624 xg_dialog_response_cb (GtkDialog
*w
,
1628 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*)user_data
;
1629 dd
->response
= response
;
1630 g_main_loop_quit (dd
->loop
);
1634 /* Destroy the dialog. This makes it pop down. */
1637 pop_down_dialog (Lisp_Object arg
)
1639 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1640 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) p
->pointer
;
1643 if (dd
->w
) gtk_widget_destroy (dd
->w
);
1644 if (dd
->timerid
!= 0) g_source_remove (dd
->timerid
);
1646 g_main_loop_quit (dd
->loop
);
1647 g_main_loop_unref (dd
->loop
);
1654 /* If there are any emacs timers pending, add a timeout to main loop in DATA.
1655 We pass in DATA as gpointer* so we can use this as a callback. */
1658 xg_maybe_add_timer (gpointer data
)
1660 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) data
;
1661 EMACS_TIME next_time
= timer_check ();
1665 if (EMACS_TIME_VALID_P (next_time
))
1667 time_t s
= EMACS_SECS (next_time
);
1668 int per_ms
= EMACS_TIME_RESOLUTION
/ 1000;
1669 int ms
= (EMACS_NSECS (next_time
) + per_ms
- 1) / per_ms
;
1670 if (s
<= ((guint
) -1 - ms
) / 1000)
1671 dd
->timerid
= g_timeout_add (s
* 1000 + ms
, xg_maybe_add_timer
, dd
);
1677 /* Pops up a modal dialog W and waits for response.
1678 We don't use gtk_dialog_run because we want to process emacs timers.
1679 The dialog W is not destroyed when this function returns. */
1682 xg_dialog_run (FRAME_PTR f
, GtkWidget
*w
)
1684 ptrdiff_t count
= SPECPDL_INDEX ();
1685 struct xg_dialog_data dd
;
1687 xg_set_screen (w
, f
);
1688 gtk_window_set_transient_for (GTK_WINDOW (w
),
1689 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1690 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1691 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1693 dd
.loop
= g_main_loop_new (NULL
, FALSE
);
1694 dd
.response
= GTK_RESPONSE_CANCEL
;
1698 g_signal_connect (G_OBJECT (w
),
1700 G_CALLBACK (xg_dialog_response_cb
),
1702 /* Don't destroy the widget if closed by the window manager close button. */
1703 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1704 gtk_widget_show (w
);
1706 record_unwind_protect (pop_down_dialog
, make_save_value (&dd
, 0));
1708 (void) xg_maybe_add_timer (&dd
);
1709 g_main_loop_run (dd
.loop
);
1712 unbind_to (count
, Qnil
);
1718 /***********************************************************************
1719 File dialog functions
1720 ***********************************************************************/
1721 /* Return non-zero if the old file selection dialog is being used.
1722 Return zero if not. */
1725 xg_uses_old_file_dialog (void)
1727 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1728 return x_gtk_use_old_file_dialog
;
1735 typedef char * (*xg_get_file_func
) (GtkWidget
*);
1737 /* Return the selected file for file chooser dialog W.
1738 The returned string must be free:d. */
1741 xg_get_file_name_from_chooser (GtkWidget
*w
)
1743 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1746 /* Callback called when the "Show hidden files" toggle is pressed.
1747 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1750 xg_toggle_visibility_cb (GtkWidget
*widget
, gpointer data
)
1752 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1754 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1755 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1759 /* Callback called when a property changes in a file chooser.
1760 GOBJECT is the file chooser dialog, ARG1 describes the property.
1761 USER_DATA is the toggle widget in the file chooser dialog.
1762 We use this to update the "Show hidden files" toggle when the user
1763 changes that property by right clicking in the file list. */
1766 xg_toggle_notify_cb (GObject
*gobject
, GParamSpec
*arg1
, gpointer user_data
)
1768 if (strcmp (arg1
->name
, "show-hidden") == 0)
1770 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1771 gboolean visible
, toggle_on
;
1773 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1774 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1776 if (!!visible
!= !!toggle_on
)
1778 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1779 G_CALLBACK (xg_toggle_visibility_cb
),
1781 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1782 g_signal_handlers_unblock_by_func
1783 (G_OBJECT (wtoggle
),
1784 G_CALLBACK (xg_toggle_visibility_cb
),
1787 x_gtk_show_hidden_files
= visible
;
1791 /* Read a file name from the user using a file chooser dialog.
1792 F is the current frame.
1793 PROMPT is a prompt to show to the user. May not be NULL.
1794 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1795 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1796 file. (Actually, this only has cosmetic effects, the user can
1797 still enter a non-existing file.) *FUNC is set to a function that
1798 can be used to retrieve the selected file name from the returned widget.
1800 Returns the created widget. */
1803 xg_get_file_with_chooser (FRAME_PTR f
,
1805 char *default_filename
,
1806 int mustmatch_p
, int only_dir_p
,
1807 xg_get_file_func
*func
)
1811 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
IF_LINT (= NULL
);
1812 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1813 GtkFileChooserAction action
= (mustmatch_p
?
1814 GTK_FILE_CHOOSER_ACTION_OPEN
:
1815 GTK_FILE_CHOOSER_ACTION_SAVE
);
1818 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1820 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1821 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1822 (mustmatch_p
|| only_dir_p
?
1823 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1826 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1828 wbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1829 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
1830 gtk_widget_show (wbox
);
1831 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1833 if (x_gtk_show_hidden_files
)
1835 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1836 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1838 gtk_widget_show (wtoggle
);
1839 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1840 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1841 g_signal_connect (G_OBJECT (filewin
), "notify",
1842 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1844 if (x_gtk_file_dialog_help_text
)
1847 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1848 Show the C-l help text only for versions < 2.10. */
1849 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1850 strcat (msgbuf
, "\nType C-l to display a file name text entry box.\n");
1851 strcat (msgbuf
, "\nIf you don't like this file selector, use the "
1852 "corresponding\nkey binding or customize "
1853 "use-file-dialog to turn it off.");
1855 wmessage
= gtk_label_new (msgbuf
);
1856 gtk_widget_show (wmessage
);
1859 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1860 if (x_gtk_file_dialog_help_text
)
1861 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1862 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1864 if (default_filename
)
1867 struct gcpro gcpro1
;
1868 char *utf8_filename
;
1871 file
= build_string (default_filename
);
1873 /* File chooser does not understand ~/... in the file name. It must be
1874 an absolute name starting with /. */
1875 if (default_filename
[0] != '/')
1876 file
= Fexpand_file_name (file
, Qnil
);
1878 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1879 if (! NILP (Ffile_directory_p (file
)))
1880 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1884 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1886 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1888 char *cp
= strrchr (utf8_filename
, '/');
1890 else cp
= utf8_filename
;
1891 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1898 *func
= xg_get_file_name_from_chooser
;
1902 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1904 /* Return the selected file for file selector dialog W.
1905 The returned string must be free:d. */
1908 xg_get_file_name_from_selector (GtkWidget
*w
)
1910 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1911 return xstrdup ((char*) gtk_file_selection_get_filename (filesel
));
1914 /* Create a file selection dialog.
1915 F is the current frame.
1916 PROMPT is a prompt to show to the user. May not be NULL.
1917 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1918 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1919 file. *FUNC is set to a function that can be used to retrieve the
1920 selected file name from the returned widget.
1922 Returns the created widget. */
1925 xg_get_file_with_selection (FRAME_PTR f
,
1927 char *default_filename
,
1928 int mustmatch_p
, int only_dir_p
,
1929 xg_get_file_func
*func
)
1932 GtkFileSelection
*filesel
;
1934 filewin
= gtk_file_selection_new (prompt
);
1935 filesel
= GTK_FILE_SELECTION (filewin
);
1937 if (default_filename
)
1938 gtk_file_selection_set_filename (filesel
, default_filename
);
1942 /* The selection_entry part of filesel is not documented. */
1943 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1944 gtk_file_selection_hide_fileop_buttons (filesel
);
1947 *func
= xg_get_file_name_from_selector
;
1951 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1953 /* Read a file name from the user using a file dialog, either the old
1954 file selection dialog, or the new file chooser dialog. Which to use
1955 depends on what the GTK version used has, and what the value of
1956 gtk-use-old-file-dialog.
1957 F is the current frame.
1958 PROMPT is a prompt to show to the user. May not be NULL.
1959 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1960 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1963 Returns a file name or NULL if no file was selected.
1964 The returned string must be freed by the caller. */
1967 xg_get_file_name (FRAME_PTR f
,
1969 char *default_filename
,
1975 int filesel_done
= 0;
1976 xg_get_file_func func
;
1978 #if defined (HAVE_PTHREAD) && defined (__SIGRTMIN)
1979 /* I really don't know why this is needed, but without this the GLIBC add on
1980 library linuxthreads hangs when the Gnome file chooser backend creates
1982 sigblock (sigmask (__SIGRTMIN
));
1983 #endif /* HAVE_PTHREAD */
1985 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1987 if (xg_uses_old_file_dialog ())
1988 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1989 mustmatch_p
, only_dir_p
, &func
);
1991 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1992 mustmatch_p
, only_dir_p
, &func
);
1994 #else /* not HAVE_GTK_FILE_SELECTION_NEW */
1995 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1996 mustmatch_p
, only_dir_p
, &func
);
1997 #endif /* not HAVE_GTK_FILE_SELECTION_NEW */
1999 gtk_widget_set_name (w
, "emacs-filedialog");
2001 filesel_done
= xg_dialog_run (f
, w
);
2003 #if defined (HAVE_PTHREAD) && defined (__SIGRTMIN)
2004 sigunblock (sigmask (__SIGRTMIN
));
2007 if (filesel_done
== GTK_RESPONSE_OK
)
2010 gtk_widget_destroy (w
);
2014 /***********************************************************************
2016 ***********************************************************************/
2018 #ifdef HAVE_FREETYPE
2020 #if USE_NEW_GTK_FONT_CHOOSER
2022 extern Lisp_Object Qxft
, Qnormal
;
2023 extern Lisp_Object Qextra_light
, Qlight
, Qsemi_light
, Qsemi_bold
;
2024 extern Lisp_Object Qbold
, Qextra_bold
, Qultra_bold
;
2025 extern Lisp_Object Qoblique
, Qitalic
;
2027 #define XG_WEIGHT_TO_SYMBOL(w) \
2028 (w <= PANGO_WEIGHT_THIN ? Qextra_light \
2029 : w <= PANGO_WEIGHT_ULTRALIGHT ? Qlight \
2030 : w <= PANGO_WEIGHT_LIGHT ? Qsemi_light \
2031 : w < PANGO_WEIGHT_MEDIUM ? Qnormal \
2032 : w <= PANGO_WEIGHT_SEMIBOLD ? Qsemi_bold \
2033 : w <= PANGO_WEIGHT_BOLD ? Qbold \
2034 : w <= PANGO_WEIGHT_HEAVY ? Qextra_bold \
2037 #define XG_STYLE_TO_SYMBOL(s) \
2038 (s == PANGO_STYLE_OBLIQUE ? Qoblique \
2039 : s == PANGO_STYLE_ITALIC ? Qitalic \
2042 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2045 static char *x_last_font_name
;
2047 /* Pop up a GTK font selector and return the name of the font the user
2048 selects, as a C string. The returned font name follows GTK's own
2051 `FAMILY [VALUE1 VALUE2] SIZE'
2053 This can be parsed using font_parse_fcname in font.c.
2054 DEFAULT_NAME, if non-zero, is the default font name. */
2057 xg_get_font (FRAME_PTR f
, const char *default_name
)
2061 Lisp_Object font
= Qnil
;
2063 #if defined (HAVE_PTHREAD) && defined (__SIGRTMIN)
2064 sigblock (sigmask (__SIGRTMIN
));
2065 #endif /* HAVE_PTHREAD */
2067 w
= gtk_font_chooser_dialog_new
2068 ("Pick a font", GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2072 /* Convert fontconfig names to Gtk names, i.e. remove - before
2074 char *p
= strrchr (default_name
, '-');
2078 while (c_isdigit (*ep
))
2080 if (*ep
== '\0') *p
= ' ';
2083 else if (x_last_font_name
)
2084 default_name
= x_last_font_name
;
2087 gtk_font_chooser_set_font (GTK_FONT_CHOOSER (w
), default_name
);
2089 gtk_widget_set_name (w
, "emacs-fontdialog");
2090 done
= xg_dialog_run (f
, w
);
2092 #if defined (HAVE_PTHREAD) && defined (__SIGRTMIN)
2093 sigunblock (sigmask (__SIGRTMIN
));
2096 if (done
== GTK_RESPONSE_OK
)
2098 #if USE_NEW_GTK_FONT_CHOOSER
2099 /* Use the GTK3 font chooser. */
2100 PangoFontDescription
*desc
2101 = gtk_font_chooser_get_font_desc (GTK_FONT_CHOOSER (w
));
2105 Lisp_Object args
[10];
2106 const char *name
= pango_font_description_get_family (desc
);
2107 gint size
= pango_font_description_get_size (desc
);
2108 PangoWeight weight
= pango_font_description_get_weight (desc
);
2109 PangoStyle style
= pango_font_description_get_style (desc
);
2112 args
[1] = build_string (name
);
2115 args
[3] = make_float (pango_units_to_double (size
));
2118 args
[5] = XG_WEIGHT_TO_SYMBOL (weight
);
2121 args
[7] = XG_STYLE_TO_SYMBOL (style
);
2126 font
= Ffont_spec (8, args
);
2128 pango_font_description_free (desc
);
2129 xfree (x_last_font_name
);
2130 x_last_font_name
= xstrdup (name
);
2133 #else /* Use old font selector, which just returns the font name. */
2136 = gtk_font_selection_dialog_get_font_name (GTK_FONT_CHOOSER (w
));
2140 font
= build_string (font_name
);
2141 g_free (x_last_font_name
);
2142 x_last_font_name
= font_name
;
2144 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2147 gtk_widget_destroy (w
);
2150 #endif /* HAVE_FREETYPE */
2154 /***********************************************************************
2156 ***********************************************************************/
2158 /* The name of menu items that can be used for customization. Since GTK
2159 RC files are very crude and primitive, we have to set this on all
2160 menu item names so a user can easily customize menu items. */
2162 #define MENU_ITEM_NAME "emacs-menuitem"
2165 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
2166 during GC. The next member points to the items. */
2167 static xg_list_node xg_menu_cb_list
;
2169 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
2170 during GC. The next member points to the items. */
2171 static xg_list_node xg_menu_item_cb_list
;
2173 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
2174 F is the frame CL_DATA will be initialized for.
2175 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2177 The menu bar and all sub menus under the menu bar in a frame
2178 share the same structure, hence the reference count.
2180 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
2181 allocated xg_menu_cb_data if CL_DATA is NULL. */
2183 static xg_menu_cb_data
*
2184 make_cl_data (xg_menu_cb_data
*cl_data
, FRAME_PTR f
, GCallback highlight_cb
)
2188 cl_data
= xmalloc (sizeof *cl_data
);
2190 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2191 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2192 cl_data
->highlight_cb
= highlight_cb
;
2193 cl_data
->ref_count
= 0;
2195 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
2198 cl_data
->ref_count
++;
2203 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
2204 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2206 When the menu bar is updated, menu items may have been added and/or
2207 removed, so menu_bar_vector and menu_bar_items_used change. We must
2208 then update CL_DATA since it is used to determine which menu
2209 item that is invoked in the menu.
2210 HIGHLIGHT_CB could change, there is no check that the same
2211 function is given when modifying a menu bar as was given when
2212 creating the menu bar. */
2215 update_cl_data (xg_menu_cb_data
*cl_data
,
2217 GCallback highlight_cb
)
2222 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2223 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2224 cl_data
->highlight_cb
= highlight_cb
;
2228 /* Decrease reference count for CL_DATA.
2229 If reference count is zero, free CL_DATA. */
2232 unref_cl_data (xg_menu_cb_data
*cl_data
)
2234 if (cl_data
&& cl_data
->ref_count
> 0)
2236 cl_data
->ref_count
--;
2237 if (cl_data
->ref_count
== 0)
2239 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
2245 /* Function that marks all lisp data during GC. */
2251 Lisp_Object rest
, frame
;
2253 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
2254 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
2256 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
2258 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
2260 if (! NILP (cb_data
->help
))
2261 mark_object (cb_data
->help
);
2264 FOR_EACH_FRAME (rest
, frame
)
2266 FRAME_PTR f
= XFRAME (frame
);
2268 if (FRAME_X_P (f
) && FRAME_GTK_OUTER_WIDGET (f
))
2270 struct xg_frame_tb_info
*tbinfo
2271 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
2275 mark_object (tbinfo
->last_tool_bar
);
2276 mark_object (tbinfo
->style
);
2283 /* Callback called when a menu item is destroyed. Used to free data.
2284 W is the widget that is being destroyed (not used).
2285 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
2288 menuitem_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2292 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
2293 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
2298 /* Callback called when the pointer enters/leaves a menu item.
2299 W is the parent of the menu item.
2300 EVENT is either an enter event or leave event.
2301 CLIENT_DATA is not used.
2303 Returns FALSE to tell GTK to keep processing this event. */
2306 menuitem_highlight_callback (GtkWidget
*w
,
2307 GdkEventCrossing
*event
,
2308 gpointer client_data
)
2311 GtkWidget
*subwidget
;
2312 xg_menu_item_cb_data
*data
;
2314 ev
.crossing
= *event
;
2315 subwidget
= gtk_get_event_widget (&ev
);
2316 data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (subwidget
),
2320 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
2322 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
2323 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
2324 (*func
) (subwidget
, call_data
);
2331 /* Callback called when a menu is destroyed. Used to free data.
2332 W is the widget that is being destroyed (not used).
2333 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
2336 menu_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2338 unref_cl_data ((xg_menu_cb_data
*) client_data
);
2341 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
2342 must be non-NULL) and can be inserted into a menu item.
2344 Returns the GtkHBox. */
2347 make_widget_for_menu_item (const char *utf8_label
, const char *utf8_key
)
2353 wbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
2354 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
2355 wlbl
= gtk_label_new (utf8_label
);
2356 wkey
= gtk_label_new (utf8_key
);
2358 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
2359 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
2361 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
2362 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
2364 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
2365 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
2366 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
2371 /* Make and return a menu item widget with the key to the right.
2372 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
2373 UTF8_KEY is the text representing the key binding.
2374 ITEM is the widget_value describing the menu item.
2376 GROUP is an in/out parameter. If the menu item to be created is not
2377 part of any radio menu group, *GROUP contains NULL on entry and exit.
2378 If the menu item to be created is part of a radio menu group, on entry
2379 *GROUP contains the group to use, or NULL if this is the first item
2380 in the group. On exit, *GROUP contains the radio item group.
2382 Unfortunately, keys don't line up as nicely as in Motif,
2383 but the MacOS X version doesn't either, so I guess that is OK. */
2386 make_menu_item (const char *utf8_label
,
2387 const char *utf8_key
,
2392 GtkWidget
*wtoadd
= 0;
2394 /* It has been observed that some menu items have a NULL name field.
2395 This will lead to this function being called with a NULL utf8_label.
2396 GTK crashes on that so we set a blank label. Why there is a NULL
2397 name remains to be investigated. */
2398 if (! utf8_label
) utf8_label
= " ";
2401 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2403 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
2406 if (utf8_key
) w
= gtk_check_menu_item_new ();
2407 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
2408 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
2410 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
2412 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
2413 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
2414 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
2416 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
2421 if (utf8_key
) w
= gtk_menu_item_new ();
2422 else w
= gtk_menu_item_new_with_label (utf8_label
);
2425 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2426 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
2431 static int xg_detached_menus
;
2433 /* Returns non-zero if there are detached menus. */
2436 xg_have_tear_offs (void)
2438 return xg_detached_menus
> 0;
2441 /* Callback invoked when a detached menu window is removed. Here we
2442 decrease the xg_detached_menus count.
2443 WIDGET is the top level window that is removed (the parent of the menu).
2444 CLIENT_DATA is not used. */
2447 tearoff_remove (GtkWidget
*widget
, gpointer client_data
)
2449 if (xg_detached_menus
> 0) --xg_detached_menus
;
2452 /* Callback invoked when a menu is detached. It increases the
2453 xg_detached_menus count.
2454 WIDGET is the GtkTearoffMenuItem.
2455 CLIENT_DATA is not used. */
2458 tearoff_activate (GtkWidget
*widget
, gpointer client_data
)
2460 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
2461 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
2463 ++xg_detached_menus
;
2464 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
2466 G_CALLBACK (tearoff_remove
), 0);
2471 /* Create a menu item widget, and connect the callbacks.
2472 ITEM describes the menu item.
2473 F is the frame the created menu belongs to.
2474 SELECT_CB is the callback to use when a menu item is selected.
2475 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2476 CL_DATA points to the callback data to be used for this menu.
2477 GROUP is an in/out parameter. If the menu item to be created is not
2478 part of any radio menu group, *GROUP contains NULL on entry and exit.
2479 If the menu item to be created is part of a radio menu group, on entry
2480 *GROUP contains the group to use, or NULL if this is the first item
2481 in the group. On exit, *GROUP contains the radio item group.
2483 Returns the created GtkWidget. */
2486 xg_create_one_menuitem (widget_value
*item
,
2488 GCallback select_cb
,
2489 GCallback highlight_cb
,
2490 xg_menu_cb_data
*cl_data
,
2496 xg_menu_item_cb_data
*cb_data
;
2498 utf8_label
= get_utf8_string (item
->name
);
2499 utf8_key
= get_utf8_string (item
->key
);
2501 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2503 if (utf8_label
) g_free (utf8_label
);
2504 if (utf8_key
) g_free (utf8_key
);
2506 cb_data
= xmalloc (sizeof *cb_data
);
2508 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
2510 cb_data
->select_id
= 0;
2511 cb_data
->help
= item
->help
;
2512 cb_data
->cl_data
= cl_data
;
2513 cb_data
->call_data
= item
->call_data
;
2515 g_signal_connect (G_OBJECT (w
),
2517 G_CALLBACK (menuitem_destroy_callback
),
2520 /* Put cb_data in widget, so we can get at it when modifying menubar */
2521 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2523 /* final item, not a submenu */
2524 if (item
->call_data
&& ! item
->contents
)
2528 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2534 /* Create a full menu tree specified by DATA.
2535 F is the frame the created menu belongs to.
2536 SELECT_CB is the callback to use when a menu item is selected.
2537 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2538 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2539 POP_UP_P is non-zero if we shall create a popup menu.
2540 MENU_BAR_P is non-zero if we shall create a menu bar.
2541 ADD_TEAROFF_P is non-zero if we shall add a tearoff menu item. Ignored
2542 if MENU_BAR_P is non-zero.
2543 TOPMENU is the topmost GtkWidget that others shall be placed under.
2544 It may be NULL, in that case we create the appropriate widget
2545 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2546 CL_DATA is the callback data we shall use for this menu, or NULL
2547 if we haven't set the first callback yet.
2548 NAME is the name to give to the top level menu if this function
2549 creates it. May be NULL to not set any name.
2551 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2554 This function calls itself to create submenus. */
2557 create_menus (widget_value
*data
,
2559 GCallback select_cb
,
2560 GCallback deactivate_cb
,
2561 GCallback highlight_cb
,
2566 xg_menu_cb_data
*cl_data
,
2570 GtkWidget
*wmenu
= topmenu
;
2571 GSList
*group
= NULL
;
2577 wmenu
= gtk_menu_new ();
2578 xg_set_screen (wmenu
, f
);
2579 /* Connect this to the menu instead of items so we get enter/leave for
2580 disabled items also. TODO: Still does not get enter/leave for
2581 disabled items in detached menus. */
2582 g_signal_connect (G_OBJECT (wmenu
),
2583 "enter-notify-event",
2584 G_CALLBACK (menuitem_highlight_callback
),
2586 g_signal_connect (G_OBJECT (wmenu
),
2587 "leave-notify-event",
2588 G_CALLBACK (menuitem_highlight_callback
),
2593 wmenu
= gtk_menu_bar_new ();
2594 /* Set width of menu bar to a small value so it doesn't enlarge
2595 a small initial frame size. The width will be set to the
2596 width of the frame later on when it is added to a container.
2597 height -1: Natural height. */
2598 gtk_widget_set_size_request (wmenu
, 1, -1);
2601 /* Put cl_data on the top menu for easier access. */
2602 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2603 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2604 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2605 G_CALLBACK (menu_destroy_callback
), cl_data
);
2608 gtk_widget_set_name (wmenu
, name
);
2611 g_signal_connect (G_OBJECT (wmenu
),
2612 "selection-done", deactivate_cb
, 0);
2615 if (! menu_bar_p
&& add_tearoff_p
)
2617 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2618 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2620 g_signal_connect (G_OBJECT (tearoff
), "activate",
2621 G_CALLBACK (tearoff_activate
), 0);
2624 for (item
= data
; item
; item
= item
->next
)
2628 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2629 && !menu_separator_name_p (item
->name
))
2632 /* A title for a popup. We do the same as GTK does when
2633 creating titles, but it does not look good. */
2635 utf8_label
= get_utf8_string (item
->name
);
2637 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
2638 w
= gtk_menu_item_new_with_label (utf8_label
);
2639 gtk_widget_set_sensitive (w
, FALSE
);
2640 if (utf8_label
) g_free (utf8_label
);
2642 else if (menu_separator_name_p (item
->name
))
2645 /* GTK only have one separator type. */
2646 w
= gtk_separator_menu_item_new ();
2650 w
= xg_create_one_menuitem (item
,
2652 item
->contents
? 0 : select_cb
,
2657 /* Create a possibly empty submenu for menu bar items, since some
2658 themes don't highlight items correctly without it. */
2659 if (item
->contents
|| menu_bar_p
)
2661 GtkWidget
*submenu
= create_menus (item
->contents
,
2672 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2676 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2677 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2683 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2684 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2685 with some text and buttons.
2686 F is the frame the created item belongs to.
2687 NAME is the name to use for the top widget.
2688 VAL is a widget_value structure describing items to be created.
2689 SELECT_CB is the callback to use when a menu item is selected or
2690 a dialog button is pressed.
2691 DEACTIVATE_CB is the callback to use when an item is deactivated.
2692 For a menu, when a sub menu is not shown anymore, for a dialog it is
2693 called when the dialog is popped down.
2694 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2696 Returns the widget created. */
2699 xg_create_widget (const char *type
, const char *name
, FRAME_PTR f
, widget_value
*val
,
2700 GCallback select_cb
, GCallback deactivate_cb
,
2701 GCallback highlight_cb
)
2704 int menu_bar_p
= strcmp (type
, "menubar") == 0;
2705 int pop_up_p
= strcmp (type
, "popup") == 0;
2707 if (strcmp (type
, "dialog") == 0)
2709 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2710 xg_set_screen (w
, f
);
2711 gtk_window_set_transient_for (GTK_WINDOW (w
),
2712 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2713 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2714 gtk_widget_set_name (w
, "emacs-dialog");
2715 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2717 else if (menu_bar_p
|| pop_up_p
)
2719 w
= create_menus (val
->contents
,
2731 /* Set the cursor to an arrow for popup menus when they are mapped.
2732 This is done by default for menu bar menus. */
2735 /* Must realize so the GdkWindow inside the widget is created. */
2736 gtk_widget_realize (w
);
2737 xg_set_cursor (w
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2742 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2749 /* Return the label for menu item WITEM. */
2752 xg_get_menu_item_label (GtkMenuItem
*witem
)
2754 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2755 return gtk_label_get_label (wlabel
);
2758 /* Return non-zero if the menu item WITEM has the text LABEL. */
2761 xg_item_label_same_p (GtkMenuItem
*witem
, const char *label
)
2764 char *utf8_label
= get_utf8_string (label
);
2765 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2767 if (! old_label
&& ! utf8_label
)
2769 else if (old_label
&& utf8_label
)
2770 is_same
= strcmp (utf8_label
, old_label
) == 0;
2772 if (utf8_label
) g_free (utf8_label
);
2777 /* Destroy widgets in LIST. */
2780 xg_destroy_widgets (GList
*list
)
2784 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2786 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2788 /* Destroying the widget will remove it from the container it is in. */
2789 gtk_widget_destroy (w
);
2793 /* Update the top level names in MENUBAR (i.e. not submenus).
2794 F is the frame the menu bar belongs to.
2795 *LIST is a list with the current menu bar names (menu item widgets).
2796 ITER is the item within *LIST that shall be updated.
2797 POS is the numerical position, starting at 0, of ITER in *LIST.
2798 VAL describes what the menu bar shall look like after the update.
2799 SELECT_CB is the callback to use when a menu item is selected.
2800 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2801 CL_DATA points to the callback data to be used for this menu bar.
2803 This function calls itself to walk through the menu bar names. */
2806 xg_update_menubar (GtkWidget
*menubar
,
2812 GCallback select_cb
,
2813 GCallback deactivate_cb
,
2814 GCallback highlight_cb
,
2815 xg_menu_cb_data
*cl_data
)
2817 if (! iter
&& ! val
)
2819 else if (iter
&& ! val
)
2821 /* Item(s) have been removed. Remove all remaining items. */
2822 xg_destroy_widgets (iter
);
2824 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2825 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2826 gtk_menu_item_new_with_label (""),
2832 else if (! iter
&& val
)
2834 /* Item(s) added. Add all new items in one call. */
2835 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2836 0, 1, 0, menubar
, cl_data
, 0);
2842 /* Below this neither iter or val is NULL */
2843 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2845 /* This item is still the same, check next item. */
2847 iter
= g_list_next (iter
);
2850 else /* This item is changed. */
2852 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2853 GtkMenuItem
*witem2
= 0;
2854 int val_in_menubar
= 0;
2855 int iter_in_new_menubar
= 0;
2859 /* See if the changed entry (val) is present later in the menu bar */
2861 iter2
&& ! val_in_menubar
;
2862 iter2
= g_list_next (iter2
))
2864 witem2
= GTK_MENU_ITEM (iter2
->data
);
2865 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2868 /* See if the current entry (iter) is present later in the
2869 specification for the new menu bar. */
2870 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2871 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2873 if (val_in_menubar
&& ! iter_in_new_menubar
)
2877 /* This corresponds to:
2882 g_object_ref (G_OBJECT (witem
));
2883 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2884 gtk_widget_destroy (GTK_WIDGET (witem
));
2886 /* Must get new list since the old changed. */
2887 g_list_free (*list
);
2888 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2889 while (nr
-- > 0) iter
= g_list_next (iter
);
2891 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2893 /* This corresponds to:
2896 Rename B to X. This might seem to be a strange thing to do,
2897 since if there is a menu under B it will be totally wrong for X.
2898 But consider editing a C file. Then there is a C-mode menu
2899 (corresponds to B above).
2900 If then doing C-x C-f the minibuf menu (X above) replaces the
2901 C-mode menu. When returning from the minibuffer, we get
2902 back the C-mode menu. Thus we do:
2903 Rename B to X (C-mode to minibuf menu)
2904 Rename X to B (minibuf to C-mode menu).
2905 If the X menu hasn't been invoked, the menu under B
2906 is up to date when leaving the minibuffer. */
2907 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2908 char *utf8_label
= get_utf8_string (val
->name
);
2909 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2911 gtk_label_set_text (wlabel
, utf8_label
);
2913 /* If this item has a submenu that has been detached, change
2914 the title in the WM decorations also. */
2915 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2916 /* Set the title of the detached window. */
2917 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2919 if (utf8_label
) g_free (utf8_label
);
2920 iter
= g_list_next (iter
);
2924 else if (! val_in_menubar
&& iter_in_new_menubar
)
2926 /* This corresponds to:
2933 GtkWidget
*w
= xg_create_one_menuitem (val
,
2940 /* Create a possibly empty submenu for menu bar items, since some
2941 themes don't highlight items correctly without it. */
2942 GtkWidget
*submenu
= create_menus (NULL
, f
,
2943 select_cb
, deactivate_cb
,
2945 0, 0, 0, 0, cl_data
, 0);
2946 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2947 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2948 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2950 g_list_free (*list
);
2951 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2952 while (nr
-- > 0) iter
= g_list_next (iter
);
2953 iter
= g_list_next (iter
);
2957 else /* if (val_in_menubar && iter_in_new_menubar) */
2960 /* This corresponds to:
2965 g_object_ref (G_OBJECT (witem2
));
2966 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2967 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2968 GTK_WIDGET (witem2
), pos
);
2969 g_object_unref (G_OBJECT (witem2
));
2971 g_list_free (*list
);
2972 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2973 while (nr
-- > 0) iter
= g_list_next (iter
);
2974 if (iter
) iter
= g_list_next (iter
);
2980 /* Update the rest of the menu bar. */
2981 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2982 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2985 /* Update the menu item W so it corresponds to VAL.
2986 SELECT_CB is the callback to use when a menu item is selected.
2987 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2988 CL_DATA is the data to set in the widget for menu invocation. */
2991 xg_update_menu_item (widget_value
*val
,
2993 GCallback select_cb
,
2994 GCallback highlight_cb
,
2995 xg_menu_cb_data
*cl_data
)
3002 const char *old_label
= 0;
3003 const char *old_key
= 0;
3004 xg_menu_item_cb_data
*cb_data
;
3006 wchild
= XG_BIN_CHILD (w
);
3007 utf8_label
= get_utf8_string (val
->name
);
3008 utf8_key
= get_utf8_string (val
->key
);
3010 /* See if W is a menu item with a key. See make_menu_item above. */
3011 if (GTK_IS_BOX (wchild
))
3013 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
3015 wlbl
= GTK_LABEL (list
->data
);
3016 wkey
= GTK_LABEL (list
->next
->data
);
3021 /* Remove the key and keep just the label. */
3022 g_object_ref (G_OBJECT (wlbl
));
3023 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
3024 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
3025 g_object_unref (G_OBJECT (wlbl
));
3030 else /* Just a label. */
3032 wlbl
= GTK_LABEL (wchild
);
3034 /* Check if there is now a key. */
3037 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
3038 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
3040 wlbl
= GTK_LABEL (list
->data
);
3041 wkey
= GTK_LABEL (list
->next
->data
);
3044 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
3045 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
3050 if (wkey
) old_key
= gtk_label_get_label (wkey
);
3051 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
3053 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
3054 gtk_label_set_text (wkey
, utf8_key
);
3056 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
3057 gtk_label_set_text (wlbl
, utf8_label
);
3059 if (utf8_key
) g_free (utf8_key
);
3060 if (utf8_label
) g_free (utf8_label
);
3062 if (! val
->enabled
&& gtk_widget_get_sensitive (w
))
3063 gtk_widget_set_sensitive (w
, FALSE
);
3064 else if (val
->enabled
&& ! gtk_widget_get_sensitive (w
))
3065 gtk_widget_set_sensitive (w
, TRUE
);
3067 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (w
),
3071 cb_data
->call_data
= val
->call_data
;
3072 cb_data
->help
= val
->help
;
3073 cb_data
->cl_data
= cl_data
;
3075 /* We assume the callback functions don't change. */
3076 if (val
->call_data
&& ! val
->contents
)
3078 /* This item shall have a select callback. */
3079 if (! cb_data
->select_id
)
3081 = g_signal_connect (G_OBJECT (w
), "activate",
3082 select_cb
, cb_data
);
3084 else if (cb_data
->select_id
)
3086 g_signal_handler_disconnect (w
, cb_data
->select_id
);
3087 cb_data
->select_id
= 0;
3092 /* Update the toggle menu item W so it corresponds to VAL. */
3095 xg_update_toggle_item (widget_value
*val
, GtkWidget
*w
)
3097 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3100 /* Update the radio menu item W so it corresponds to VAL. */
3103 xg_update_radio_item (widget_value
*val
, GtkWidget
*w
)
3105 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3108 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
3109 SUBMENU may be NULL, in that case a new menu is created.
3110 F is the frame the menu bar belongs to.
3111 VAL describes the contents of the menu bar.
3112 SELECT_CB is the callback to use when a menu item is selected.
3113 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3114 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
3115 CL_DATA is the call back data to use for any newly created items.
3117 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
3121 xg_update_submenu (GtkWidget
*submenu
,
3124 GCallback select_cb
,
3125 GCallback deactivate_cb
,
3126 GCallback highlight_cb
,
3127 xg_menu_cb_data
*cl_data
)
3129 GtkWidget
*newsub
= submenu
;
3133 int has_tearoff_p
= 0;
3134 GList
*first_radio
= 0;
3137 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
3139 for (cur
= val
, iter
= list
;
3141 iter
= g_list_next (iter
), cur
= cur
->next
)
3143 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3145 /* Skip tearoff items, they have no counterpart in val. */
3146 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
3149 iter
= g_list_next (iter
);
3150 if (iter
) w
= GTK_WIDGET (iter
->data
);
3154 /* Remember first radio button in a group. If we get a mismatch in
3155 a radio group we must rebuild the whole group so that the connections
3156 in GTK becomes correct. */
3157 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
3159 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
3160 && ! GTK_IS_RADIO_MENU_ITEM (w
))
3163 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
3165 if (! menu_separator_name_p (cur
->name
))
3168 else if (GTK_IS_CHECK_MENU_ITEM (w
))
3170 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
3172 xg_update_toggle_item (cur
, w
);
3173 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3175 else if (GTK_IS_RADIO_MENU_ITEM (w
))
3177 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
3179 xg_update_radio_item (cur
, w
);
3180 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3182 else if (GTK_IS_MENU_ITEM (w
))
3184 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
3187 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
3188 menu_separator_name_p (cur
->name
))
3191 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3193 sub
= gtk_menu_item_get_submenu (witem
);
3194 if (sub
&& ! cur
->contents
)
3196 /* Not a submenu anymore. */
3197 g_object_ref (G_OBJECT (sub
));
3198 remove_submenu (witem
);
3199 gtk_widget_destroy (sub
);
3201 else if (cur
->contents
)
3205 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
3206 select_cb
, deactivate_cb
,
3207 highlight_cb
, cl_data
);
3209 /* If this item just became a submenu, we must set it. */
3211 gtk_menu_item_set_submenu (witem
, nsub
);
3216 /* Structural difference. Remove everything from here and down
3222 /* Remove widgets from first structural change. */
3225 /* If we are adding new menu items below, we must remove from
3226 first radio button so that radio groups become correct. */
3227 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
3228 else xg_destroy_widgets (iter
);
3233 /* More items added. Create them. */
3234 newsub
= create_menus (cur
,
3247 if (list
) g_list_free (list
);
3252 /* Update the MENUBAR.
3253 F is the frame the menu bar belongs to.
3254 VAL describes the contents of the menu bar.
3255 If DEEP_P is non-zero, rebuild all but the top level menu names in
3256 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
3257 SELECT_CB is the callback to use when a menu item is selected.
3258 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3259 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
3262 xg_modify_menubar_widgets (GtkWidget
*menubar
, FRAME_PTR f
, widget_value
*val
,
3264 GCallback select_cb
, GCallback deactivate_cb
,
3265 GCallback highlight_cb
)
3267 xg_menu_cb_data
*cl_data
;
3268 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
3272 cl_data
= (xg_menu_cb_data
*) g_object_get_data (G_OBJECT (menubar
),
3275 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
3276 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
3282 /* Update all sub menus.
3283 We must keep the submenus (GTK menu item widgets) since the
3284 X Window in the XEvent that activates the menu are those widgets. */
3286 /* Update cl_data, menu_item things in F may have changed. */
3287 update_cl_data (cl_data
, f
, highlight_cb
);
3289 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
3294 GtkMenuItem
*witem
= 0;
3296 /* Find sub menu that corresponds to val and update it. */
3297 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3299 witem
= GTK_MENU_ITEM (iter
->data
);
3300 if (xg_item_label_same_p (witem
, cur
->name
))
3302 sub
= gtk_menu_item_get_submenu (witem
);
3307 newsub
= xg_update_submenu (sub
,
3314 /* sub may still be NULL. If we just updated non deep and added
3315 a new menu bar item, it has no sub menu yet. So we set the
3316 newly created sub menu under witem. */
3317 if (newsub
!= sub
&& witem
!= 0)
3319 xg_set_screen (newsub
, f
);
3320 gtk_menu_item_set_submenu (witem
, newsub
);
3326 gtk_widget_show_all (menubar
);
3329 /* Callback called when the menu bar W is mapped.
3330 Used to find the height of the menu bar if we didn't get it
3331 after showing the widget. */
3334 menubar_map_cb (GtkWidget
*w
, gpointer user_data
)
3337 FRAME_PTR f
= (FRAME_PTR
) user_data
;
3338 gtk_widget_get_preferred_size (w
, NULL
, &req
);
3339 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3341 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3342 xg_height_or_width_changed (f
);
3346 /* Recompute all the widgets of frame F, when the menu bar has been
3347 changed. Value is non-zero if widgets were updated. */
3350 xg_update_frame_menubar (FRAME_PTR f
)
3352 struct x_output
*x
= f
->output_data
.x
;
3355 if (!x
->menubar_widget
|| gtk_widget_get_mapped (x
->menubar_widget
))
3358 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
3359 return 0; /* Already done this, happens for frames created invisible. */
3363 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
3365 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
3367 g_signal_connect (x
->menubar_widget
, "map", G_CALLBACK (menubar_map_cb
), f
);
3368 gtk_widget_show_all (x
->menubar_widget
);
3369 gtk_widget_get_preferred_size (x
->menubar_widget
, NULL
, &req
);
3371 /* If menu bar doesn't know its height yet, cheat a little so the frame
3372 doesn't jump so much when resized later in menubar_map_cb. */
3373 if (req
.height
== 0)
3376 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3378 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3379 xg_height_or_width_changed (f
);
3386 /* Get rid of the menu bar of frame F, and free its storage.
3387 This is used when deleting a frame, and when turning off the menu bar. */
3390 free_frame_menubar (FRAME_PTR f
)
3392 struct x_output
*x
= f
->output_data
.x
;
3394 if (x
->menubar_widget
)
3398 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
3399 /* The menubar and its children shall be deleted when removed from
3401 x
->menubar_widget
= 0;
3402 FRAME_MENUBAR_HEIGHT (f
) = 0;
3403 xg_height_or_width_changed (f
);
3409 xg_event_is_for_menubar (FRAME_PTR f
, XEvent
*event
)
3411 struct x_output
*x
= f
->output_data
.x
;
3420 if (! x
->menubar_widget
) return 0;
3422 if (! (event
->xbutton
.x
>= 0
3423 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
3424 && event
->xbutton
.y
>= 0
3425 && event
->xbutton
.y
< f
->output_data
.x
->menubar_height
3426 && event
->xbutton
.same_screen
))
3429 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3430 gw
= gdk_x11_window_lookup_for_display (gdpy
, event
->xbutton
.window
);
3432 gevent
.any
.window
= gw
;
3433 gevent
.any
.type
= GDK_NOTHING
;
3434 gwdesc
= gtk_get_event_widget (&gevent
);
3435 if (! gwdesc
) return 0;
3436 if (! GTK_IS_MENU_BAR (gwdesc
)
3437 && ! GTK_IS_MENU_ITEM (gwdesc
)
3438 && ! gtk_widget_is_ancestor (x
->menubar_widget
, gwdesc
))
3441 list
= gtk_container_get_children (GTK_CONTAINER (x
->menubar_widget
));
3442 if (! list
) return 0;
3443 rec
.x
= event
->xbutton
.x
;
3444 rec
.y
= event
->xbutton
.y
;
3448 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3450 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3451 if (gtk_widget_get_mapped (w
) && gtk_widget_intersect (w
, &rec
, NULL
))
3455 return iter
== 0 ? 0 : 1;
3460 /***********************************************************************
3461 Scroll bar functions
3462 ***********************************************************************/
3465 /* Setting scroll bar values invokes the callback. Use this variable
3466 to indicate that callback should do nothing. */
3468 int xg_ignore_gtk_scrollbar
;
3470 /* The width of the scroll bar for the current theme. */
3472 static int scroll_bar_width_for_theme
;
3474 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
3475 may be larger than 32 bits. Keep a mapping from integer index to widget
3476 pointers to get around the 32 bit limitation. */
3480 GtkWidget
**widgets
;
3485 /* Grow this much every time we need to allocate more */
3487 #define ID_TO_WIDGET_INCR 32
3489 /* Store the widget pointer W in id_to_widget and return the integer index. */
3492 xg_store_widget_in_map (GtkWidget
*w
)
3496 if (id_to_widget
.max_size
== id_to_widget
.used
)
3499 if (TYPE_MAXIMUM (Window
) - ID_TO_WIDGET_INCR
< id_to_widget
.max_size
)
3500 memory_full (SIZE_MAX
);
3502 new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
3503 id_to_widget
.widgets
= xnrealloc (id_to_widget
.widgets
,
3504 new_size
, sizeof (GtkWidget
*));
3506 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
3507 id_to_widget
.widgets
[i
] = 0;
3508 id_to_widget
.max_size
= new_size
;
3511 /* Just loop over the array and find a free place. After all,
3512 how many scroll bars are we creating? Should be a small number.
3513 The check above guarantees we will find a free place. */
3514 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
3516 if (! id_to_widget
.widgets
[i
])
3518 id_to_widget
.widgets
[i
] = w
;
3519 ++id_to_widget
.used
;
3525 /* Should never end up here */
3529 /* Remove pointer at IDX from id_to_widget.
3530 Called when scroll bar is destroyed. */
3533 xg_remove_widget_from_map (ptrdiff_t idx
)
3535 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3537 id_to_widget
.widgets
[idx
] = 0;
3538 --id_to_widget
.used
;
3542 /* Get the widget pointer at IDX from id_to_widget. */
3545 xg_get_widget_from_map (ptrdiff_t idx
)
3547 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3548 return id_to_widget
.widgets
[idx
];
3554 update_theme_scrollbar_width (void)
3557 GtkAdjustment
*vadj
;
3564 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
, 0.1, 0.1, 0.1);
3565 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3566 g_object_ref_sink (G_OBJECT (wscroll
));
3567 gtk_widget_style_get (wscroll
, "slider-width", &w
, "trough-border", &b
, NULL
);
3568 gtk_widget_destroy (wscroll
);
3569 g_object_unref (G_OBJECT (wscroll
));
3572 scroll_bar_width_for_theme
= w
;
3576 xg_get_default_scrollbar_width (void)
3578 return scroll_bar_width_for_theme
;
3581 /* Return the scrollbar id for X Window WID on display DPY.
3582 Return -1 if WID not in id_to_widget. */
3585 xg_get_scroll_id_for_window (Display
*dpy
, Window wid
)
3590 w
= xg_win_to_widget (dpy
, wid
);
3594 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3595 if (id_to_widget
.widgets
[idx
] == w
)
3602 /* Callback invoked when scroll bar WIDGET is destroyed.
3603 DATA is the index into id_to_widget for WIDGET.
3604 We free pointer to last scroll bar values here and remove the index. */
3607 xg_gtk_scroll_destroy (GtkWidget
*widget
, gpointer data
)
3609 intptr_t id
= (intptr_t) data
;
3610 xg_remove_widget_from_map (id
);
3613 /* Create a scroll bar widget for frame F. Store the scroll bar
3615 SCROLL_CALLBACK is the callback to invoke when the value of the
3617 END_CALLBACK is the callback to invoke when scrolling ends.
3618 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3619 to set resources for the widget. */
3622 xg_create_scroll_bar (FRAME_PTR f
,
3623 struct scroll_bar
*bar
,
3624 GCallback scroll_callback
,
3625 GCallback end_callback
,
3626 const char *scroll_bar_name
)
3632 GtkAdjustment
*vadj
;
3637 /* Page, step increment values are not so important here, they
3638 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3639 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3642 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3643 webox
= gtk_event_box_new ();
3644 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3646 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3648 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3650 scroll_id
= xg_store_widget_in_map (wscroll
);
3652 g_signal_connect (G_OBJECT (wscroll
),
3654 G_CALLBACK (xg_gtk_scroll_destroy
),
3655 (gpointer
) scroll_id
);
3656 g_signal_connect (G_OBJECT (wscroll
),
3660 g_signal_connect (G_OBJECT (wscroll
),
3661 "button-release-event",
3665 /* The scroll bar widget does not draw on a window of its own. Instead
3666 it draws on the parent window, in this case the edit widget. So
3667 whenever the edit widget is cleared, the scroll bar needs to redraw
3668 also, which causes flicker. Put an event box between the edit widget
3669 and the scroll bar, so the scroll bar instead draws itself on the
3670 event box window. */
3671 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3672 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3675 /* Set the cursor to an arrow. */
3676 xg_set_cursor (webox
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
3678 bar
->x_window
= scroll_id
;
3681 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3684 xg_remove_scroll_bar (FRAME_PTR f
, ptrdiff_t scrollbar_id
)
3686 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3689 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3690 gtk_widget_destroy (w
);
3691 gtk_widget_destroy (wparent
);
3692 SET_FRAME_GARBAGED (f
);
3696 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3698 TOP/LEFT are the new pixel positions where the bar shall appear.
3699 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3702 xg_update_scrollbar_pos (FRAME_PTR f
,
3703 ptrdiff_t scrollbar_id
,
3710 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3714 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3715 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3718 /* Clear out old position. */
3719 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3720 if (gtk_widget_get_parent (wparent
) == wfixed
)
3722 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3723 "x", &oldx
, "y", &oldy
, NULL
);
3724 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3727 /* Move and resize to new values. */
3728 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3729 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3732 /* No room. Hide scroll bar as some themes output a warning if
3733 the height is less than the min size. */
3734 gtk_widget_hide (wparent
);
3735 gtk_widget_hide (wscroll
);
3739 gtk_widget_show_all (wparent
);
3740 gtk_widget_set_size_request (wscroll
, width
, height
);
3742 gtk_widget_queue_draw (wfixed
);
3743 gdk_window_process_all_updates ();
3744 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3746 /* Clear under old scroll bar position. This must be done after
3747 the gtk_widget_queue_draw and gdk_window_process_all_updates
3749 x_clear_area (FRAME_X_DISPLAY (f
),
3751 oldx
, oldy
, oldw
, oldh
, 0);
3754 /* GTK does not redraw until the main loop is entered again, but
3755 if there are no X events pending we will not enter it. So we sync
3756 here to get some events. */
3759 SET_FRAME_GARBAGED (f
);
3760 cancel_mouse_face (f
);
3764 /* Get the current value of the range, truncated to an integer. */
3767 int_gtk_range_get_value (GtkRange
*range
)
3769 return gtk_range_get_value (range
);
3773 /* Set the thumb size and position of scroll bar BAR. We are currently
3774 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3777 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
,
3782 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3784 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3786 if (wscroll
&& NILP (bar
->dragging
))
3796 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3798 /* We do the same as for MOTIF in xterm.c, assume 30 chars per line
3799 rather than the real portion value. This makes the thumb less likely
3800 to resize and that looks better. */
3801 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3802 /* When the thumb is at the bottom, position == whole.
3803 So we need to increase `whole' to make space for the thumb. */
3810 top
= (gdouble
) position
/ whole
;
3811 shown
= (gdouble
) portion
/ whole
;
3814 size
= shown
* XG_SB_RANGE
;
3815 size
= min (size
, XG_SB_RANGE
);
3816 size
= max (size
, 1);
3818 value
= top
* XG_SB_RANGE
;
3819 value
= min (value
, XG_SB_MAX
- size
);
3820 value
= max (value
, XG_SB_MIN
);
3822 /* Assume all lines are of equal size. */
3823 new_step
= size
/ max (1, FRAME_LINES (f
));
3825 old_size
= gtk_adjustment_get_page_size (adj
);
3826 if (old_size
!= size
)
3828 int old_step
= gtk_adjustment_get_step_increment (adj
);
3829 if (old_step
!= new_step
)
3831 gtk_adjustment_set_page_size (adj
, size
);
3832 gtk_adjustment_set_step_increment (adj
, new_step
);
3833 /* Assume a page increment is about 95% of the page size */
3834 gtk_adjustment_set_page_increment (adj
, size
- size
/ 20);
3839 if (changed
|| int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3843 /* gtk_range_set_value invokes the callback. Set
3844 ignore_gtk_scrollbar to make the callback do nothing */
3845 xg_ignore_gtk_scrollbar
= 1;
3847 if (int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3848 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3850 gtk_adjustment_changed (adj
);
3852 xg_ignore_gtk_scrollbar
= 0;
3859 /* Return non-zero if EVENT is for a scroll bar in frame F.
3860 When the same X window is used for several Gtk+ widgets, we cannot
3861 say for sure based on the X window alone if an event is for the
3862 frame. This function does additional checks.
3864 Return non-zero if the event is for a scroll bar, zero otherwise. */
3867 xg_event_is_for_scrollbar (FRAME_PTR f
, XEvent
*event
)
3871 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
3873 /* Check if press occurred outside the edit widget. */
3874 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3877 GdkDevice
*gdev
= gdk_device_manager_get_client_pointer
3878 (gdk_display_get_device_manager (gdpy
));
3879 gwin
= gdk_device_get_window_at_position (gdev
, NULL
, NULL
);
3881 gwin
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
);
3883 retval
= gwin
!= gtk_widget_get_window (f
->output_data
.x
->edit_widget
);
3886 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
3887 || event
->type
== MotionNotify
))
3889 /* If we are releasing or moving the scroll bar, it has the grab. */
3890 GtkWidget
*w
= gtk_grab_get_current ();
3891 retval
= w
!= 0 && GTK_IS_SCROLLBAR (w
);
3899 /***********************************************************************
3901 ***********************************************************************/
3902 /* The key for the data we put in the GtkImage widgets. The data is
3903 the image used by Emacs. We use this to see if we need to update
3904 the GtkImage with a new image. */
3905 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3907 /* The key for storing the latest modifiers so the activate callback can
3909 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
3911 /* The key for storing the button widget in its proxy menu item. */
3912 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
3914 /* The key for the data we put in the GtkImage widgets. The data is
3915 the stock name used by Emacs. We use this to see if we need to update
3916 the GtkImage with a new image. */
3917 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
3919 /* As above, but this is used for named theme widgets, as opposed to
3921 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
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_button_cb (GtkWidget
*widget
,
3930 GdkEventButton
*event
,
3933 intptr_t state
= event
->state
;
3934 gpointer ptr
= (gpointer
) state
;
3935 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
3940 /* Callback function invoked when a tool bar item is pressed.
3941 W is the button widget in the tool bar that got pressed,
3942 CLIENT_DATA is an integer that is the index of the button in the
3943 tool bar. 0 is the first button. */
3946 xg_tool_bar_callback (GtkWidget
*w
, gpointer client_data
)
3948 intptr_t idx
= (intptr_t) client_data
;
3949 gpointer gmod
= g_object_get_data (G_OBJECT (w
), XG_TOOL_BAR_LAST_MODIFIER
);
3950 intptr_t mod
= (intptr_t) gmod
;
3952 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3953 Lisp_Object key
, frame
;
3954 struct input_event event
;
3957 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3960 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3962 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3963 XSETFRAME (frame
, f
);
3965 /* We generate two events here. The first one is to set the prefix
3966 to `(tool_bar)', see keyboard.c. */
3967 event
.kind
= TOOL_BAR_EVENT
;
3968 event
.frame_or_window
= frame
;
3970 kbd_buffer_store_event (&event
);
3972 event
.kind
= TOOL_BAR_EVENT
;
3973 event
.frame_or_window
= frame
;
3975 /* Convert between the modifier bits GDK uses and the modifier bits
3976 Emacs uses. This assumes GDK and X masks are the same, which they are when
3978 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), mod
);
3979 kbd_buffer_store_event (&event
);
3981 /* Return focus to the frame after we have clicked on a detached
3983 Fx_focus_frame (frame
);
3986 /* Callback function invoked when a tool bar item is pressed in a detached
3987 tool bar or the overflow drop down menu.
3988 We just call xg_tool_bar_callback.
3989 W is the menu item widget that got pressed,
3990 CLIENT_DATA is an integer that is the index of the button in the
3991 tool bar. 0 is the first button. */
3994 xg_tool_bar_proxy_callback (GtkWidget
*w
, gpointer client_data
)
3996 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3997 XG_TOOL_BAR_PROXY_BUTTON
));
3998 xg_tool_bar_callback (wbutton
, client_data
);
4003 xg_tool_bar_help_callback (GtkWidget
*w
,
4004 GdkEventCrossing
*event
,
4005 gpointer client_data
);
4007 /* This callback is called when a help is to be shown for an item in
4008 the detached tool bar when the detached tool bar it is not expanded. */
4011 xg_tool_bar_proxy_help_callback (GtkWidget
*w
,
4012 GdkEventCrossing
*event
,
4013 gpointer client_data
)
4015 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
4016 XG_TOOL_BAR_PROXY_BUTTON
));
4018 return xg_tool_bar_help_callback (wbutton
, event
, client_data
);
4022 xg_get_tool_bar_widgets (GtkWidget
*vb
, GtkWidget
**wimage
)
4024 GList
*clist
= gtk_container_get_children (GTK_CONTAINER (vb
));
4025 GtkWidget
*c1
= (GtkWidget
*) clist
->data
;
4026 GtkWidget
*c2
= clist
->next
? (GtkWidget
*) clist
->next
->data
: NULL
;
4028 *wimage
= GTK_IS_IMAGE (c1
) ? c1
: c2
;
4029 g_list_free (clist
);
4030 return GTK_IS_LABEL (c1
) ? c1
: c2
;
4034 /* This callback is called when a tool item should create a proxy item,
4035 such as for the overflow menu. Also called when the tool bar is detached.
4036 If we don't create a proxy menu item, the detached tool bar will be
4040 xg_tool_bar_menu_proxy (GtkToolItem
*toolitem
, gpointer user_data
)
4042 GtkButton
*wbutton
= GTK_BUTTON (XG_BIN_CHILD (XG_BIN_CHILD (toolitem
)));
4043 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4045 GtkLabel
*wlbl
= GTK_LABEL (xg_get_tool_bar_widgets (vb
, &c1
));
4046 GtkImage
*wimage
= GTK_IMAGE (c1
);
4047 GtkWidget
*wmenuitem
= gtk_image_menu_item_new_with_label
4048 (wlbl
? gtk_label_get_text (wlbl
) : "");
4049 GtkWidget
*wmenuimage
;
4052 if (gtk_button_get_use_stock (wbutton
))
4053 wmenuimage
= gtk_image_new_from_stock (gtk_button_get_label (wbutton
),
4054 GTK_ICON_SIZE_MENU
);
4057 GtkSettings
*settings
= gtk_widget_get_settings (GTK_WIDGET (wbutton
));
4058 GtkImageType store_type
= gtk_image_get_storage_type (wimage
);
4060 g_object_set (G_OBJECT (settings
), "gtk-menu-images", TRUE
, NULL
);
4062 if (store_type
== GTK_IMAGE_STOCK
)
4065 gtk_image_get_stock (wimage
, &stock_id
, NULL
);
4066 wmenuimage
= gtk_image_new_from_stock (stock_id
, GTK_ICON_SIZE_MENU
);
4068 else if (store_type
== GTK_IMAGE_ICON_SET
)
4070 GtkIconSet
*icon_set
;
4071 gtk_image_get_icon_set (wimage
, &icon_set
, NULL
);
4072 wmenuimage
= gtk_image_new_from_icon_set (icon_set
,
4073 GTK_ICON_SIZE_MENU
);
4075 else if (store_type
== GTK_IMAGE_PIXBUF
)
4080 gtk_icon_size_lookup_for_settings (settings
, GTK_ICON_SIZE_MENU
,
4083 GdkPixbuf
*src_pixbuf
, *dest_pixbuf
;
4085 src_pixbuf
= gtk_image_get_pixbuf (wimage
);
4086 dest_pixbuf
= gdk_pixbuf_scale_simple (src_pixbuf
, width
, height
,
4087 GDK_INTERP_BILINEAR
);
4089 wmenuimage
= gtk_image_new_from_pixbuf (dest_pixbuf
);
4093 fprintf (stderr
, "internal error: GTK_IMAGE_PIXBUF failed\n");
4097 else if (store_type
== GTK_IMAGE_ICON_NAME
)
4099 const gchar
*icon_name
;
4100 GtkIconSize icon_size
;
4102 gtk_image_get_icon_name (wimage
, &icon_name
, &icon_size
);
4103 wmenuimage
= gtk_image_new_from_icon_name (icon_name
,
4104 GTK_ICON_SIZE_MENU
);
4108 fprintf (stderr
, "internal error: store_type is %d\n", store_type
);
4113 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem
), wmenuimage
);
4115 g_signal_connect (G_OBJECT (wmenuitem
),
4117 G_CALLBACK (xg_tool_bar_proxy_callback
),
4121 g_object_set_data (G_OBJECT (wmenuitem
), XG_TOOL_BAR_PROXY_BUTTON
,
4122 (gpointer
) wbutton
);
4123 gtk_tool_item_set_proxy_menu_item (toolitem
, "Emacs toolbar item", wmenuitem
);
4124 gtk_widget_set_sensitive (wmenuitem
,
4125 gtk_widget_get_sensitive (GTK_WIDGET (wbutton
)));
4127 /* Use enter/leave notify to show help. We use the events
4128 rather than the GtkButton specific signals "enter" and
4129 "leave", so we can have only one callback. The event
4130 will tell us what kind of event it is. */
4131 g_signal_connect (G_OBJECT (wmenuitem
),
4132 "enter-notify-event",
4133 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
4135 g_signal_connect (G_OBJECT (wmenuitem
),
4136 "leave-notify-event",
4137 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
4143 /* This callback is called when a tool bar is detached. We must set
4144 the height of the tool bar to zero when this happens so frame sizes
4145 are correctly calculated.
4146 WBOX is the handle box widget that enables detach/attach of the tool bar.
4147 W is the tool bar widget.
4148 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
4151 xg_tool_bar_detach_callback (GtkHandleBox
*wbox
,
4153 gpointer client_data
)
4155 FRAME_PTR f
= (FRAME_PTR
) client_data
;
4157 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
4162 GtkRequisition req
, req2
;
4163 FRAME_X_OUTPUT (f
)->toolbar_detached
= 1;
4164 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
4165 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
4166 req
.width
-= req2
.width
;
4167 req
.height
-= req2
.height
;
4168 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
4169 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
4170 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
4171 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
4172 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
4173 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
4174 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
4175 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
4176 xg_height_or_width_changed (f
);
4180 /* This callback is called when a tool bar is reattached. We must set
4181 the height of the tool bar when this happens so frame sizes
4182 are correctly calculated.
4183 WBOX is the handle box widget that enables detach/attach of the tool bar.
4184 W is the tool bar widget.
4185 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
4188 xg_tool_bar_attach_callback (GtkHandleBox
*wbox
,
4190 gpointer client_data
)
4192 FRAME_PTR f
= (FRAME_PTR
) client_data
;
4193 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
4197 GtkRequisition req
, req2
;
4198 FRAME_X_OUTPUT (f
)->toolbar_detached
= 0;
4199 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
4200 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
4201 req
.width
+= req2
.width
;
4202 req
.height
+= req2
.height
;
4203 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
4204 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
4205 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
4206 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
4207 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
4208 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
4209 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
4210 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
4211 xg_height_or_width_changed (f
);
4215 /* This callback is called when the mouse enters or leaves a tool bar item.
4216 It is used for displaying and hiding the help text.
4217 W is the tool bar item, a button.
4218 EVENT is either an enter event or leave event.
4219 CLIENT_DATA is an integer that is the index of the button in the
4220 tool bar. 0 is the first button.
4222 Returns FALSE to tell GTK to keep processing this event. */
4225 xg_tool_bar_help_callback (GtkWidget
*w
,
4226 GdkEventCrossing
*event
,
4227 gpointer client_data
)
4229 intptr_t idx
= (intptr_t) client_data
;
4230 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
4231 Lisp_Object help
, frame
;
4233 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
4236 if (event
->type
== GDK_ENTER_NOTIFY
)
4238 idx
*= TOOL_BAR_ITEM_NSLOTS
;
4239 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
4242 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
4247 XSETFRAME (frame
, f
);
4248 kbd_buffer_store_help_event (frame
, help
);
4254 /* This callback is called when a tool bar item shall be redrawn.
4255 It modifies the expose event so that the GtkImage widget redraws the
4256 whole image. This to overcome a bug that makes GtkImage draw the image
4257 in the wrong place when it tries to redraw just a part of the image.
4258 W is the GtkImage to be redrawn.
4259 EVENT is the expose event for W.
4260 CLIENT_DATA is unused.
4262 Returns FALSE to tell GTK to keep processing this event. */
4266 xg_tool_bar_item_expose_callback (GtkWidget
*w
,
4267 GdkEventExpose
*event
,
4268 gpointer client_data
)
4272 gdk_drawable_get_size (event
->window
, &width
, &height
);
4273 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
4274 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
4276 event
->area
.x
= max (0, event
->area
.x
);
4277 event
->area
.y
= max (0, event
->area
.y
);
4279 event
->area
.width
= max (width
, event
->area
.width
);
4280 event
->area
.height
= max (height
, event
->area
.height
);
4286 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
4287 #define toolbar_set_orientation(w, o) \
4288 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
4290 #define toolbar_set_orientation(w, o) \
4291 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
4294 /* Attach a tool bar to frame F. */
4297 xg_pack_tool_bar (FRAME_PTR f
, Lisp_Object pos
)
4299 struct x_output
*x
= f
->output_data
.x
;
4300 int into_hbox
= EQ (pos
, Qleft
) || EQ (pos
, Qright
);
4302 toolbar_set_orientation (x
->toolbar_widget
,
4304 ? GTK_ORIENTATION_VERTICAL
4305 : GTK_ORIENTATION_HORIZONTAL
);
4306 if (!x
->handlebox_widget
)
4308 x
->handlebox_widget
= gtk_handle_box_new ();
4309 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
4310 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
4311 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
4312 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
4313 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
4319 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4321 gtk_box_pack_start (GTK_BOX (x
->hbox_widget
), x
->handlebox_widget
,
4324 if (EQ (pos
, Qleft
))
4325 gtk_box_reorder_child (GTK_BOX (x
->hbox_widget
),
4326 x
->handlebox_widget
,
4328 x
->toolbar_in_hbox
= 1;
4332 int vbox_pos
= x
->menubar_widget
? 1 : 0;
4333 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4335 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
4339 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
),
4340 x
->handlebox_widget
,
4342 x
->toolbar_in_hbox
= 0;
4346 /* Create a tool bar for frame F. */
4349 xg_create_tool_bar (FRAME_PTR f
)
4351 struct x_output
*x
= f
->output_data
.x
;
4352 #if GTK_CHECK_VERSION (3, 3, 6)
4353 GtkStyleContext
*gsty
;
4355 struct xg_frame_tb_info
*tbinfo
4356 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4360 tbinfo
= xmalloc (sizeof (*tbinfo
));
4361 tbinfo
->last_tool_bar
= Qnil
;
4362 tbinfo
->style
= Qnil
;
4363 tbinfo
->hmargin
= tbinfo
->vmargin
= 0;
4364 tbinfo
->dir
= GTK_TEXT_DIR_NONE
;
4365 tbinfo
->n_last_items
= 0;
4366 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4371 x
->toolbar_widget
= gtk_toolbar_new ();
4372 x
->toolbar_detached
= 0;
4374 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
4376 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
4377 toolbar_set_orientation (x
->toolbar_widget
, GTK_ORIENTATION_HORIZONTAL
);
4378 #if GTK_CHECK_VERSION (3, 3, 6)
4379 gsty
= gtk_widget_get_style_context (x
->toolbar_widget
);
4380 gtk_style_context_add_class (gsty
, "primary-toolbar");
4385 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
4387 /* Find the right-to-left image named by RTL in the tool bar images for F.
4388 Returns IMAGE if RTL is not found. */
4391 find_rtl_image (FRAME_PTR f
, Lisp_Object image
, Lisp_Object rtl
)
4394 Lisp_Object file
, rtl_name
;
4395 struct gcpro gcpro1
, gcpro2
;
4396 GCPRO2 (file
, rtl_name
);
4398 rtl_name
= Ffile_name_nondirectory (rtl
);
4400 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
4402 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4403 if (!NILP (file
= file_for_image (rtl_image
)))
4405 file
= call1 (intern ("file-name-sans-extension"),
4406 Ffile_name_nondirectory (file
));
4407 if (! NILP (Fequal (file
, rtl_name
)))
4418 static GtkToolItem
*
4419 xg_make_tool_item (FRAME_PTR f
,
4421 GtkWidget
**wbutton
,
4423 int i
, int horiz
, int text_image
)
4425 GtkToolItem
*ti
= gtk_tool_item_new ();
4426 GtkWidget
*vb
= gtk_box_new (horiz
4427 ? GTK_ORIENTATION_HORIZONTAL
4428 : GTK_ORIENTATION_VERTICAL
,
4430 GtkWidget
*wb
= gtk_button_new ();
4431 /* The eventbox is here so we can have tooltips on disabled items. */
4432 GtkWidget
*weventbox
= gtk_event_box_new ();
4433 #if GTK_CHECK_VERSION (3, 3, 6)
4434 GtkCssProvider
*css_prov
= gtk_css_provider_new ();
4435 GtkStyleContext
*gsty
;
4437 gtk_css_provider_load_from_data (css_prov
,
4439 " background-color: transparent;"
4443 gsty
= gtk_widget_get_style_context (weventbox
);
4444 gtk_style_context_add_provider (gsty
,
4445 GTK_STYLE_PROVIDER (css_prov
),
4446 GTK_STYLE_PROVIDER_PRIORITY_USER
);
4447 g_object_unref (css_prov
);
4450 gtk_box_set_homogeneous (GTK_BOX (vb
), FALSE
);
4452 if (wimage
&& !text_image
)
4453 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4455 gtk_box_pack_start (GTK_BOX (vb
), gtk_label_new (label
), TRUE
, TRUE
, 0);
4456 if (wimage
&& text_image
)
4457 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4459 gtk_button_set_focus_on_click (GTK_BUTTON (wb
), FALSE
);
4460 gtk_button_set_relief (GTK_BUTTON (wb
), GTK_RELIEF_NONE
);
4461 gtk_container_add (GTK_CONTAINER (wb
), vb
);
4462 gtk_container_add (GTK_CONTAINER (weventbox
), wb
);
4463 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
4465 if (wimage
|| label
)
4468 gpointer gi
= (gpointer
) ii
;
4470 g_signal_connect (G_OBJECT (ti
), "create-menu-proxy",
4471 G_CALLBACK (xg_tool_bar_menu_proxy
),
4474 g_signal_connect (G_OBJECT (wb
), "clicked",
4475 G_CALLBACK (xg_tool_bar_callback
),
4478 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
4481 /* Catch expose events to overcome an annoying redraw bug, see
4482 comment for xg_tool_bar_item_expose_callback. */
4483 g_signal_connect (G_OBJECT (ti
),
4485 G_CALLBACK (xg_tool_bar_item_expose_callback
),
4488 gtk_tool_item_set_homogeneous (ti
, FALSE
);
4490 /* Callback to save modifier mask (Shift/Control, etc). GTK makes
4491 no distinction based on modifiers in the activate callback,
4492 so we have to do it ourselves. */
4493 g_signal_connect (wb
, "button-release-event",
4494 G_CALLBACK (xg_tool_bar_button_cb
),
4497 g_object_set_data (G_OBJECT (wb
), XG_FRAME_DATA
, (gpointer
)f
);
4499 /* Use enter/leave notify to show help. We use the events
4500 rather than the GtkButton specific signals "enter" and
4501 "leave", so we can have only one callback. The event
4502 will tell us what kind of event it is. */
4503 g_signal_connect (G_OBJECT (weventbox
),
4504 "enter-notify-event",
4505 G_CALLBACK (xg_tool_bar_help_callback
),
4507 g_signal_connect (G_OBJECT (weventbox
),
4508 "leave-notify-event",
4509 G_CALLBACK (xg_tool_bar_help_callback
),
4513 if (wbutton
) *wbutton
= wb
;
4519 is_box_type (GtkWidget
*vb
, int is_horizontal
)
4523 if (GTK_IS_BOX (vb
))
4525 GtkOrientation ori
= gtk_orientable_get_orientation (GTK_ORIENTABLE (vb
));
4526 ret
= (ori
== GTK_ORIENTATION_HORIZONTAL
&& is_horizontal
)
4527 || (ori
== GTK_ORIENTATION_VERTICAL
&& ! is_horizontal
);
4531 return is_horizontal
? GTK_IS_VBOX (vb
) : GTK_IS_HBOX (vb
);
4537 xg_tool_item_stale_p (GtkWidget
*wbutton
, const char *stock_name
,
4538 const char *icon_name
, const struct image
*img
,
4539 const char *label
, int horiz
)
4543 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4544 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
4546 /* Check if the tool icon matches. */
4547 if (stock_name
&& wimage
)
4549 old
= g_object_get_data (G_OBJECT (wimage
),
4550 XG_TOOL_BAR_STOCK_NAME
);
4551 if (!old
|| strcmp (old
, stock_name
))
4554 else if (icon_name
&& wimage
)
4556 old
= g_object_get_data (G_OBJECT (wimage
),
4557 XG_TOOL_BAR_ICON_NAME
);
4558 if (!old
|| strcmp (old
, icon_name
))
4563 gpointer gold_img
= g_object_get_data (G_OBJECT (wimage
),
4564 XG_TOOL_BAR_IMAGE_DATA
);
4565 Pixmap old_img
= (Pixmap
) gold_img
;
4566 if (old_img
!= img
->pixmap
)
4570 /* Check button configuration and label. */
4571 if (is_box_type (vb
, horiz
)
4572 || (label
? (wlbl
== NULL
) : (wlbl
!= NULL
)))
4575 /* Ensure label is correct. */
4577 gtk_label_set_text (GTK_LABEL (wlbl
), label
);
4582 xg_update_tool_bar_sizes (FRAME_PTR f
)
4584 struct x_output
*x
= f
->output_data
.x
;
4586 int nl
= 0, nr
= 0, nt
= 0, nb
= 0;
4588 gtk_widget_get_preferred_size (GTK_WIDGET (x
->handlebox_widget
), NULL
, &req
);
4589 if (x
->toolbar_in_hbox
)
4592 gtk_container_child_get (GTK_CONTAINER (x
->hbox_widget
),
4593 x
->handlebox_widget
,
4594 "position", &pos
, NULL
);
4595 if (pos
== 0) nl
= req
.width
;
4596 else nr
= req
.width
;
4601 gtk_container_child_get (GTK_CONTAINER (x
->vbox_widget
),
4602 x
->handlebox_widget
,
4603 "position", &pos
, NULL
);
4604 if (pos
== 0 || (pos
== 1 && x
->menubar_widget
)) nt
= req
.height
;
4605 else nb
= req
.height
;
4608 if (nl
!= FRAME_TOOLBAR_LEFT_WIDTH (f
)
4609 || nr
!= FRAME_TOOLBAR_RIGHT_WIDTH (f
)
4610 || nt
!= FRAME_TOOLBAR_TOP_HEIGHT (f
)
4611 || nb
!= FRAME_TOOLBAR_BOTTOM_HEIGHT (f
))
4613 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = FRAME_TOOLBAR_LEFT_WIDTH (f
)
4614 = FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4615 FRAME_TOOLBAR_LEFT_WIDTH (f
) = nl
;
4616 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = nr
;
4617 FRAME_TOOLBAR_TOP_HEIGHT (f
) = nt
;
4618 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = nb
;
4626 /* Update the tool bar for frame F. Add new buttons and remove old. */
4629 update_frame_tool_bar (FRAME_PTR f
)
4632 struct x_output
*x
= f
->output_data
.x
;
4633 int hmargin
= 0, vmargin
= 0;
4634 GtkToolbar
*wtoolbar
;
4636 GtkTextDirection dir
;
4637 int pack_tool_bar
= x
->handlebox_widget
== NULL
;
4639 int text_image
, horiz
;
4640 struct xg_frame_tb_info
*tbinfo
;
4642 if (! FRAME_GTK_WIDGET (f
))
4647 if (RANGED_INTEGERP (1, Vtool_bar_button_margin
, INT_MAX
))
4649 hmargin
= XFASTINT (Vtool_bar_button_margin
);
4650 vmargin
= XFASTINT (Vtool_bar_button_margin
);
4652 else if (CONSP (Vtool_bar_button_margin
))
4654 if (RANGED_INTEGERP (1, XCAR (Vtool_bar_button_margin
), INT_MAX
))
4655 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
4657 if (RANGED_INTEGERP (1, XCDR (Vtool_bar_button_margin
), INT_MAX
))
4658 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
4661 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
4662 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
4663 i.e. zero. This means that margins less than
4664 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
4665 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4666 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4668 if (! x
->toolbar_widget
)
4669 xg_create_tool_bar (f
);
4671 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
4672 dir
= gtk_widget_get_direction (GTK_WIDGET (wtoolbar
));
4674 style
= Ftool_bar_get_system_style ();
4676 /* Are we up to date? */
4677 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4680 if (! NILP (tbinfo
->last_tool_bar
) && ! NILP (f
->tool_bar_items
)
4681 && tbinfo
->n_last_items
== f
->n_tool_bar_items
4682 && tbinfo
->hmargin
== hmargin
&& tbinfo
->vmargin
== vmargin
4683 && tbinfo
->dir
== dir
4684 && ! NILP (Fequal (tbinfo
->style
, style
))
4685 && ! NILP (Fequal (tbinfo
->last_tool_bar
, f
->tool_bar_items
)))
4691 tbinfo
->last_tool_bar
= f
->tool_bar_items
;
4692 tbinfo
->n_last_items
= f
->n_tool_bar_items
;
4693 tbinfo
->style
= style
;
4694 tbinfo
->hmargin
= hmargin
;
4695 tbinfo
->vmargin
= vmargin
;
4698 text_image
= EQ (style
, Qtext_image_horiz
);
4699 horiz
= EQ (style
, Qboth_horiz
) || text_image
;
4701 for (i
= j
= 0; i
< f
->n_tool_bar_items
; ++i
)
4703 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
4704 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
4708 struct image
*img
= NULL
;
4710 Lisp_Object stock
= Qnil
;
4711 GtkStockItem stock_item
;
4712 char *stock_name
= NULL
;
4713 char *icon_name
= NULL
;
4715 GtkWidget
*wbutton
= NULL
;
4716 Lisp_Object specified_file
;
4717 int vert_only
= ! NILP (PROP (TOOL_BAR_ITEM_VERT_ONLY
));
4719 = (EQ (style
, Qimage
) || (vert_only
&& horiz
)) ? NULL
4720 : STRINGP (PROP (TOOL_BAR_ITEM_LABEL
))
4721 ? SSDATA (PROP (TOOL_BAR_ITEM_LABEL
))
4724 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4726 /* If this is a separator, use a gtk separator item. */
4727 if (EQ (PROP (TOOL_BAR_ITEM_TYPE
), Qt
))
4729 if (ti
== NULL
|| !GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4732 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4734 ti
= gtk_separator_tool_item_new ();
4735 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4741 /* Otherwise, the tool-bar item is an ordinary button. */
4743 if (ti
&& GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4745 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4749 if (ti
) wbutton
= XG_BIN_CHILD (XG_BIN_CHILD (ti
));
4751 /* Ignore invalid image specifications. */
4752 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4753 if (!valid_image_p (image
))
4756 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4761 specified_file
= file_for_image (image
);
4762 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
4763 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
4765 if (STRINGP (stock
))
4767 stock_name
= SSDATA (stock
);
4768 if (stock_name
[0] == 'n' && stock_name
[1] == ':')
4770 GdkScreen
*screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
4771 GtkIconTheme
*icon_theme
= gtk_icon_theme_get_for_screen (screen
);
4773 icon_name
= stock_name
+ 2;
4777 if (! gtk_icon_theme_has_icon (icon_theme
, icon_name
))
4780 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4782 else if (gtk_stock_lookup (SSDATA (stock
), &stock_item
))
4783 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4791 if (stock_name
== NULL
&& icon_name
== NULL
)
4793 /* No stock image, or stock item not known. Try regular
4794 image. If image is a vector, choose it according to the
4796 if (dir
== GTK_TEXT_DIR_RTL
4797 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
4799 image
= find_rtl_image (f
, image
, rtl
);
4801 if (VECTORP (image
))
4805 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
4806 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
4809 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
4810 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
4812 eassert (ASIZE (image
) >= idx
);
4813 image
= AREF (image
, idx
);
4818 img_id
= lookup_image (f
, image
);
4819 img
= IMAGE_FROM_ID (f
, img_id
);
4820 prepare_image_for_display (f
, img
);
4822 if (img
->load_failed_p
|| img
->pixmap
== None
)
4825 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4831 /* If there is an existing widget, check if it's stale; if so,
4832 remove it and make a new tool item from scratch. */
4833 if (ti
&& xg_tool_item_stale_p (wbutton
, stock_name
, icon_name
,
4836 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4845 /* Save the image so we can see if an update is needed the
4846 next time we call xg_tool_item_match_p. */
4847 if (EQ (style
, Qtext
))
4849 else if (stock_name
)
4851 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
4852 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
4853 (gpointer
) xstrdup (stock_name
),
4854 (GDestroyNotify
) xfree
);
4858 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
4859 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
4860 (gpointer
) xstrdup (icon_name
),
4861 (GDestroyNotify
) xfree
);
4865 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
4866 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
4867 (gpointer
)img
->pixmap
);
4870 if (w
) gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
4871 ti
= xg_make_tool_item (f
, w
, &wbutton
, label
, i
, horiz
, text_image
);
4872 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4877 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4881 /* Remove buttons not longer needed. */
4884 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4886 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4887 } while (ti
!= NULL
);
4889 if (f
->n_tool_bar_items
!= 0)
4892 xg_pack_tool_bar (f
, f
->tool_bar_position
);
4893 gtk_widget_show_all (GTK_WIDGET (x
->handlebox_widget
));
4894 if (xg_update_tool_bar_sizes (f
))
4895 xg_height_or_width_changed (f
);
4901 /* Deallocate all resources for the tool bar on frame F.
4902 Remove the tool bar. */
4905 free_frame_tool_bar (FRAME_PTR f
)
4907 struct x_output
*x
= f
->output_data
.x
;
4909 if (x
->toolbar_widget
)
4911 struct xg_frame_tb_info
*tbinfo
;
4912 int is_packed
= x
->handlebox_widget
!= 0;
4914 /* We may have created the toolbar_widget in xg_create_tool_bar, but
4915 not the x->handlebox_widget which is created in xg_pack_tool_bar. */
4918 if (x
->toolbar_in_hbox
)
4919 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4920 x
->handlebox_widget
);
4922 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4923 x
->handlebox_widget
);
4926 gtk_widget_destroy (x
->toolbar_widget
);
4928 x
->toolbar_widget
= 0;
4929 x
->handlebox_widget
= 0;
4930 FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4931 FRAME_TOOLBAR_LEFT_WIDTH (f
) = FRAME_TOOLBAR_RIGHT_WIDTH (f
) = 0;
4933 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4938 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4943 xg_height_or_width_changed (f
);
4950 xg_change_toolbar_position (FRAME_PTR f
, Lisp_Object pos
)
4952 struct x_output
*x
= f
->output_data
.x
;
4954 if (! x
->toolbar_widget
|| ! x
->handlebox_widget
)
4958 g_object_ref (x
->handlebox_widget
);
4959 if (x
->toolbar_in_hbox
)
4960 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4961 x
->handlebox_widget
);
4963 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4964 x
->handlebox_widget
);
4965 xg_pack_tool_bar (f
, pos
);
4966 g_object_unref (x
->handlebox_widget
);
4967 if (xg_update_tool_bar_sizes (f
))
4968 xg_height_or_width_changed (f
);
4976 /***********************************************************************
4978 ***********************************************************************/
4980 xg_initialize (void)
4982 GtkBindingSet
*binding_set
;
4983 GtkSettings
*settings
;
4986 /* Work around a bug with corrupted data if libXft gets unloaded. This way
4987 we keep it permanently linked in. */
4992 xg_ignore_gtk_scrollbar
= 0;
4993 xg_detached_menus
= 0;
4994 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
4995 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
4997 id_to_widget
.max_size
= id_to_widget
.used
= 0;
4998 id_to_widget
.widgets
= 0;
5000 settings
= gtk_settings_get_for_screen (gdk_display_get_default_screen
5001 (gdk_display_get_default ()));
5002 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
5003 bindings. It doesn't seem to be any way to remove properties,
5004 so we set it to VoidSymbol which in X means "no key". */
5005 gtk_settings_set_string_property (settings
,
5006 "gtk-menu-bar-accel",
5010 /* Make GTK text input widgets use Emacs style keybindings. This is
5012 gtk_settings_set_string_property (settings
,
5013 "gtk-key-theme-name",
5017 /* Make dialogs close on C-g. Since file dialog inherits from
5018 dialog, this works for them also. */
5019 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
5020 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
5023 /* Make menus close on C-g. */
5024 binding_set
= gtk_binding_set_by_class (g_type_class_ref
5025 (GTK_TYPE_MENU_SHELL
));
5026 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
5028 update_theme_scrollbar_width ();
5030 x_last_font_name
= NULL
;
5033 #endif /* USE_GTK */